diff --git a/lib/commonjs/ReactNativeSVG.js b/lib/commonjs/ReactNativeSVG.js new file mode 100644 index 00000000..13e54a29 --- /dev/null +++ b/lib/commonjs/ReactNativeSVG.js @@ -0,0 +1,361 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var _exportNames = { + Shape: true, + camelCase: true, + parse: true, + SvgAst: true, + SvgFromUri: true, + SvgFromXml: true, + SvgUri: true, + SvgXml: true, + fetchText: true, + RNSVGCircle: true, + RNSVGClipPath: true, + RNSVGDefs: true, + RNSVGEllipse: true, + RNSVGFeColorMatrix: true, + RNSVGFeComposite: true, + RNSVGFeGaussianBlur: true, + RNSVGFeMerge: true, + RNSVGFeOffset: true, + RNSVGFilter: true, + RNSVGForeignObject: true, + RNSVGGroup: true, + RNSVGImage: true, + RNSVGLine: true, + RNSVGLinearGradient: true, + RNSVGMarker: true, + RNSVGMask: true, + RNSVGPath: true, + RNSVGPattern: true, + RNSVGRadialGradient: true, + RNSVGRect: true, + RNSVGSvgAndroid: true, + RNSVGSvgIOS: true, + RNSVGSymbol: true, + RNSVGText: true, + RNSVGTextPath: true, + RNSVGTSpan: true, + RNSVGUse: true, + inlineStyles: true, + loadLocalRawResource: true, + LocalSvg: true, + SvgCss: true, + SvgCssUri: true, + SvgWithCss: true, + SvgWithCssUri: true, + WithLocalSvg: true +}; +Object.defineProperty(exports, "LocalSvg", { + enumerable: true, + get: function () { + return _deprecated.LocalSvg; + } +}); +Object.defineProperty(exports, "RNSVGCircle", { + enumerable: true, + get: function () { + return _fabric.RNSVGCircle; + } +}); +Object.defineProperty(exports, "RNSVGClipPath", { + enumerable: true, + get: function () { + return _fabric.RNSVGClipPath; + } +}); +Object.defineProperty(exports, "RNSVGDefs", { + enumerable: true, + get: function () { + return _fabric.RNSVGDefs; + } +}); +Object.defineProperty(exports, "RNSVGEllipse", { + enumerable: true, + get: function () { + return _fabric.RNSVGEllipse; + } +}); +Object.defineProperty(exports, "RNSVGFeColorMatrix", { + enumerable: true, + get: function () { + return _fabric.RNSVGFeColorMatrix; + } +}); +Object.defineProperty(exports, "RNSVGFeComposite", { + enumerable: true, + get: function () { + return _fabric.RNSVGFeComposite; + } +}); +Object.defineProperty(exports, "RNSVGFeGaussianBlur", { + enumerable: true, + get: function () { + return _fabric.RNSVGFeGaussianBlur; + } +}); +Object.defineProperty(exports, "RNSVGFeMerge", { + enumerable: true, + get: function () { + return _fabric.RNSVGFeMerge; + } +}); +Object.defineProperty(exports, "RNSVGFeOffset", { + enumerable: true, + get: function () { + return _fabric.RNSVGFeOffset; + } +}); +Object.defineProperty(exports, "RNSVGFilter", { + enumerable: true, + get: function () { + return _fabric.RNSVGFilter; + } +}); +Object.defineProperty(exports, "RNSVGForeignObject", { + enumerable: true, + get: function () { + return _fabric.RNSVGForeignObject; + } +}); +Object.defineProperty(exports, "RNSVGGroup", { + enumerable: true, + get: function () { + return _fabric.RNSVGGroup; + } +}); +Object.defineProperty(exports, "RNSVGImage", { + enumerable: true, + get: function () { + return _fabric.RNSVGImage; + } +}); +Object.defineProperty(exports, "RNSVGLine", { + enumerable: true, + get: function () { + return _fabric.RNSVGLine; + } +}); +Object.defineProperty(exports, "RNSVGLinearGradient", { + enumerable: true, + get: function () { + return _fabric.RNSVGLinearGradient; + } +}); +Object.defineProperty(exports, "RNSVGMarker", { + enumerable: true, + get: function () { + return _fabric.RNSVGMarker; + } +}); +Object.defineProperty(exports, "RNSVGMask", { + enumerable: true, + get: function () { + return _fabric.RNSVGMask; + } +}); +Object.defineProperty(exports, "RNSVGPath", { + enumerable: true, + get: function () { + return _fabric.RNSVGPath; + } +}); +Object.defineProperty(exports, "RNSVGPattern", { + enumerable: true, + get: function () { + return _fabric.RNSVGPattern; + } +}); +Object.defineProperty(exports, "RNSVGRadialGradient", { + enumerable: true, + get: function () { + return _fabric.RNSVGRadialGradient; + } +}); +Object.defineProperty(exports, "RNSVGRect", { + enumerable: true, + get: function () { + return _fabric.RNSVGRect; + } +}); +Object.defineProperty(exports, "RNSVGSvgAndroid", { + enumerable: true, + get: function () { + return _fabric.RNSVGSvgAndroid; + } +}); +Object.defineProperty(exports, "RNSVGSvgIOS", { + enumerable: true, + get: function () { + return _fabric.RNSVGSvgIOS; + } +}); +Object.defineProperty(exports, "RNSVGSymbol", { + enumerable: true, + get: function () { + return _fabric.RNSVGSymbol; + } +}); +Object.defineProperty(exports, "RNSVGTSpan", { + enumerable: true, + get: function () { + return _fabric.RNSVGTSpan; + } +}); +Object.defineProperty(exports, "RNSVGText", { + enumerable: true, + get: function () { + return _fabric.RNSVGText; + } +}); +Object.defineProperty(exports, "RNSVGTextPath", { + enumerable: true, + get: function () { + return _fabric.RNSVGTextPath; + } +}); +Object.defineProperty(exports, "RNSVGUse", { + enumerable: true, + get: function () { + return _fabric.RNSVGUse; + } +}); +Object.defineProperty(exports, "Shape", { + enumerable: true, + get: function () { + return _Shape.default; + } +}); +Object.defineProperty(exports, "SvgAst", { + enumerable: true, + get: function () { + return _xml.SvgAst; + } +}); +Object.defineProperty(exports, "SvgCss", { + enumerable: true, + get: function () { + return _deprecated.SvgCss; + } +}); +Object.defineProperty(exports, "SvgCssUri", { + enumerable: true, + get: function () { + return _deprecated.SvgCssUri; + } +}); +Object.defineProperty(exports, "SvgFromUri", { + enumerable: true, + get: function () { + return _xml.SvgFromUri; + } +}); +Object.defineProperty(exports, "SvgFromXml", { + enumerable: true, + get: function () { + return _xml.SvgFromXml; + } +}); +Object.defineProperty(exports, "SvgUri", { + enumerable: true, + get: function () { + return _xml.SvgUri; + } +}); +Object.defineProperty(exports, "SvgWithCss", { + enumerable: true, + get: function () { + return _deprecated.SvgWithCss; + } +}); +Object.defineProperty(exports, "SvgWithCssUri", { + enumerable: true, + get: function () { + return _deprecated.SvgWithCssUri; + } +}); +Object.defineProperty(exports, "SvgXml", { + enumerable: true, + get: function () { + return _xml.SvgXml; + } +}); +Object.defineProperty(exports, "WithLocalSvg", { + enumerable: true, + get: function () { + return _deprecated.WithLocalSvg; + } +}); +Object.defineProperty(exports, "camelCase", { + enumerable: true, + get: function () { + return _xml.camelCase; + } +}); +Object.defineProperty(exports, "default", { + enumerable: true, + get: function () { + return _elements.default; + } +}); +Object.defineProperty(exports, "fetchText", { + enumerable: true, + get: function () { + return _fetchData.fetchText; + } +}); +Object.defineProperty(exports, "inlineStyles", { + enumerable: true, + get: function () { + return _deprecated.inlineStyles; + } +}); +Object.defineProperty(exports, "loadLocalRawResource", { + enumerable: true, + get: function () { + return _deprecated.loadLocalRawResource; + } +}); +Object.defineProperty(exports, "parse", { + enumerable: true, + get: function () { + return _xml.parse; + } +}); +var _Shape = _interopRequireDefault(require("./elements/Shape")); +var _xml = require("./xml"); +var _fetchData = require("./utils/fetchData"); +var _fabric = require("./fabric"); +var _deprecated = require("./deprecated"); +var _types = require("./lib/extract/types"); +Object.keys(_types).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _types[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _types[key]; + } + }); +}); +var _elements = _interopRequireWildcard(require("./elements")); +Object.keys(_elements).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _elements[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _elements[key]; + } + }); +}); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +//# sourceMappingURL=ReactNativeSVG.js.map \ No newline at end of file diff --git a/lib/commonjs/ReactNativeSVG.js.map b/lib/commonjs/ReactNativeSVG.js.map new file mode 100644 index 00000000..c37bbb91 --- /dev/null +++ b/lib/commonjs/ReactNativeSVG.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_Shape","_interopRequireDefault","require","_xml","_fetchData","_fabric","_deprecated","_types","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_elements","_interopRequireWildcard","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","n","__proto__","a","getOwnPropertyDescriptor","u","i","set"],"sourceRoot":"../../src","sources":["ReactNativeSVG.ts"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/lib/commonjs/ReactNativeSVG.web.js b/lib/commonjs/ReactNativeSVG.web.js new file mode 100644 index 00000000..18822131 --- /dev/null +++ b/lib/commonjs/ReactNativeSVG.web.js @@ -0,0 +1,155 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var _exportNames = { + camelCase: true, + parse: true, + SvgAst: true, + SvgFromUri: true, + SvgFromXml: true, + SvgUri: true, + SvgXml: true, + fetchText: true, + inlineStyles: true, + loadLocalRawResource: true, + LocalSvg: true, + SvgCss: true, + SvgCssUri: true, + SvgWithCss: true, + SvgWithCssUri: true, + WithLocalSvg: true +}; +Object.defineProperty(exports, "LocalSvg", { + enumerable: true, + get: function () { + return _deprecated.LocalSvg; + } +}); +Object.defineProperty(exports, "SvgAst", { + enumerable: true, + get: function () { + return _xml.SvgAst; + } +}); +Object.defineProperty(exports, "SvgCss", { + enumerable: true, + get: function () { + return _deprecated.SvgCss; + } +}); +Object.defineProperty(exports, "SvgCssUri", { + enumerable: true, + get: function () { + return _deprecated.SvgCssUri; + } +}); +Object.defineProperty(exports, "SvgFromUri", { + enumerable: true, + get: function () { + return _xml.SvgFromUri; + } +}); +Object.defineProperty(exports, "SvgFromXml", { + enumerable: true, + get: function () { + return _xml.SvgFromXml; + } +}); +Object.defineProperty(exports, "SvgUri", { + enumerable: true, + get: function () { + return _xml.SvgUri; + } +}); +Object.defineProperty(exports, "SvgWithCss", { + enumerable: true, + get: function () { + return _deprecated.SvgWithCss; + } +}); +Object.defineProperty(exports, "SvgWithCssUri", { + enumerable: true, + get: function () { + return _deprecated.SvgWithCssUri; + } +}); +Object.defineProperty(exports, "SvgXml", { + enumerable: true, + get: function () { + return _xml.SvgXml; + } +}); +Object.defineProperty(exports, "WithLocalSvg", { + enumerable: true, + get: function () { + return _deprecated.WithLocalSvg; + } +}); +Object.defineProperty(exports, "camelCase", { + enumerable: true, + get: function () { + return _xml.camelCase; + } +}); +Object.defineProperty(exports, "default", { + enumerable: true, + get: function () { + return _elements.default; + } +}); +Object.defineProperty(exports, "fetchText", { + enumerable: true, + get: function () { + return _fetchData.fetchText; + } +}); +Object.defineProperty(exports, "inlineStyles", { + enumerable: true, + get: function () { + return _deprecated.inlineStyles; + } +}); +Object.defineProperty(exports, "loadLocalRawResource", { + enumerable: true, + get: function () { + return _deprecated.loadLocalRawResource; + } +}); +Object.defineProperty(exports, "parse", { + enumerable: true, + get: function () { + return _xml.parse; + } +}); +var _xml = require("./xml"); +var _fetchData = require("./utils/fetchData"); +var _deprecated = require("./deprecated"); +var _types = require("./lib/extract/types"); +Object.keys(_types).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _types[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _types[key]; + } + }); +}); +var _elements = _interopRequireWildcard(require("./elements")); +Object.keys(_elements).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _elements[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _elements[key]; + } + }); +}); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } +//# sourceMappingURL=ReactNativeSVG.web.js.map \ No newline at end of file diff --git a/lib/commonjs/ReactNativeSVG.web.js.map b/lib/commonjs/ReactNativeSVG.web.js.map new file mode 100644 index 00000000..535632aa --- /dev/null +++ b/lib/commonjs/ReactNativeSVG.web.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_xml","require","_fetchData","_deprecated","_types","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_elements","_interopRequireWildcard","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","n","__proto__","a","getOwnPropertyDescriptor","u","i","set"],"sourceRoot":"../../src","sources":["ReactNativeSVG.web.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,IAAA,GAAAC,OAAA;AAmBA,IAAAC,UAAA,GAAAD,OAAA;AAEA,IAAAE,WAAA,GAAAF,OAAA;AAsBA,IAAAG,MAAA,GAAAH,OAAA;AAAAI,MAAA,CAAAC,IAAA,CAAAF,MAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,MAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,MAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,SAAA,GAAAC,uBAAA,CAAAjB,OAAA;AAAAI,MAAA,CAAAC,IAAA,CAAAW,SAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAS,SAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,SAAA,CAAAT,GAAA;IAAA;EAAA;AAAA;AAA2B,SAAAW,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAF,wBAAAE,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,WAAAK,OAAA,EAAAL,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAP,GAAA,CAAAI,CAAA,OAAAO,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAxB,MAAA,CAAAS,cAAA,IAAAT,MAAA,CAAAyB,wBAAA,WAAAC,CAAA,IAAAX,CAAA,oBAAAW,CAAA,OAAArB,cAAA,CAAAC,IAAA,CAAAS,CAAA,EAAAW,CAAA,SAAAC,CAAA,GAAAH,CAAA,GAAAxB,MAAA,CAAAyB,wBAAA,CAAAV,CAAA,EAAAW,CAAA,UAAAC,CAAA,KAAAA,CAAA,CAAAhB,GAAA,IAAAgB,CAAA,CAAAC,GAAA,IAAA5B,MAAA,CAAAS,cAAA,CAAAa,CAAA,EAAAI,CAAA,EAAAC,CAAA,IAAAL,CAAA,CAAAI,CAAA,IAAAX,CAAA,CAAAW,CAAA,YAAAJ,CAAA,CAAAF,OAAA,GAAAL,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAU,GAAA,CAAAb,CAAA,EAAAO,CAAA,GAAAA,CAAA","ignoreList":[]} \ No newline at end of file diff --git a/lib/commonjs/css/LocalSvg.js b/lib/commonjs/css/LocalSvg.js new file mode 100644 index 00000000..041594f2 --- /dev/null +++ b/lib/commonjs/css/LocalSvg.js @@ -0,0 +1,108 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.LocalSvg = LocalSvg; +exports.default = exports.WithLocalSvg = void 0; +exports.getUriFromSource = getUriFromSource; +exports.isUriAnAndroidResourceIdentifier = isUriAnAndroidResourceIdentifier; +exports.loadAndroidRawResource = loadAndroidRawResource; +exports.loadLocalRawResource = void 0; +exports.loadLocalRawResourceAndroid = loadLocalRawResourceAndroid; +exports.loadLocalRawResourceDefault = loadLocalRawResourceDefault; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _reactNative = require("react-native"); +var _reactNativeSvg = require("react-native-svg"); +var _resolveAssetUri = require("../lib/resolveAssetUri"); +var _css = require("./css"); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function getUriFromSource(source) { + const resolvedAssetSource = _reactNative.Platform.OS === 'web' ? (0, _resolveAssetUri.resolveAssetUri)(source) : _reactNative.Image.resolveAssetSource(source); + return resolvedAssetSource === null || resolvedAssetSource === void 0 ? void 0 : resolvedAssetSource.uri; +} +function loadLocalRawResourceDefault(source) { + const uri = getUriFromSource(source); + return (0, _reactNativeSvg.fetchText)(uri); +} +function isUriAnAndroidResourceIdentifier(uri) { + return typeof uri === 'string' && uri.indexOf('/') <= -1; +} +async function loadAndroidRawResource(uri) { + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const RNSVGRenderableModule = + // neeeded for new arch + // eslint-disable-next-line @typescript-eslint/no-var-requires + require('../fabric/NativeSvgRenderableModule').default; + return await RNSVGRenderableModule.getRawResource(uri); + } catch (e) { + console.error('Error in RawResourceUtils while trying to natively load an Android raw resource: ', e); + return null; + } +} +function loadLocalRawResourceAndroid(source) { + const uri = getUriFromSource(source); + if (uri && isUriAnAndroidResourceIdentifier(uri)) { + return loadAndroidRawResource(uri); + } else { + return (0, _reactNativeSvg.fetchText)(uri); + } +} +const loadLocalRawResource = exports.loadLocalRawResource = _reactNative.Platform.OS !== 'android' ? loadLocalRawResourceDefault : loadLocalRawResourceAndroid; +function LocalSvg(props) { + const { + asset, + ...rest + } = props; + const [xml, setXml] = (0, _react.useState)(null); + (0, _react.useEffect)(() => { + loadLocalRawResource(asset).then(setXml); + }, [asset]); + return /*#__PURE__*/React.createElement(_css.SvgCss, _extends({ + xml: xml + }, rest)); +} +class WithLocalSvg extends _react.Component { + state = { + xml: null + }; + componentDidMount() { + this.load(this.props.asset); + } + componentDidUpdate(prevProps) { + const { + asset + } = this.props; + if (asset !== prevProps.asset) { + this.load(asset); + } + } + async load(asset) { + try { + this.setState({ + xml: asset ? await loadLocalRawResource(asset) : null + }); + } catch (e) { + console.error(e); + } + } + render() { + const { + props, + state: { + xml + } + } = this; + return /*#__PURE__*/React.createElement(_css.SvgWithCss, { + xml: xml, + override: props + }); + } +} +exports.WithLocalSvg = WithLocalSvg; +var _default = exports.default = LocalSvg; +//# sourceMappingURL=LocalSvg.js.map \ No newline at end of file diff --git a/lib/commonjs/css/LocalSvg.js.map b/lib/commonjs/css/LocalSvg.js.map new file mode 100644 index 00000000..8364fc3d --- /dev/null +++ b/lib/commonjs/css/LocalSvg.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_react","_interopRequireWildcard","require","React","_reactNative","_reactNativeSvg","_resolveAssetUri","_css","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","_extends","assign","bind","arguments","length","apply","getUriFromSource","source","resolvedAssetSource","Platform","OS","resolveAssetUri","Image","resolveAssetSource","uri","loadLocalRawResourceDefault","fetchText","isUriAnAndroidResourceIdentifier","indexOf","loadAndroidRawResource","RNSVGRenderableModule","getRawResource","console","error","loadLocalRawResourceAndroid","loadLocalRawResource","exports","LocalSvg","props","asset","rest","xml","setXml","useState","useEffect","then","createElement","SvgCss","WithLocalSvg","Component","state","componentDidMount","load","componentDidUpdate","prevProps","setState","render","SvgWithCss","override","_default"],"sourceRoot":"../../../src","sources":["css/LocalSvg.tsx"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/lib/commonjs/css/css.js b/lib/commonjs/css/css.js new file mode 100644 index 00000000..345b552c --- /dev/null +++ b/lib/commonjs/css/css.js @@ -0,0 +1,799 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.SvgCss = SvgCss; +exports.SvgCssUri = SvgCssUri; +exports.inlineStyles = exports.SvgWithCssUri = exports.SvgWithCss = void 0; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _reactNativeSvg = require("react-native-svg"); +var _cssTree = _interopRequireWildcard(require("css-tree")); +var _cssSelect = _interopRequireDefault(require("css-select")); +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } +const err = console.error.bind(console); + +/* + * Style element inlining experiment based on SVGO + * https://github.com/svg/svgo/blob/11f9c797411a8de966aacc4cb83dbb3e471757bc/plugins/inlineStyles.js + * */ + +/** + * DOMUtils API for rnsvg AST (used by css-select) + */ +// is the node a tag? +// isTag: ( node:Node ) => isTag:Boolean +function isTag(node) { + return typeof node === 'object'; +} + +// get the parent of the node +// getParent: ( node:Node ) => parentNode:Node +// returns null when no parent exists +function getParent(node) { + return typeof node === 'object' && node.parent || null; +} + +// get the node's children +// getChildren: ( node:Node ) => children:[Node] +function getChildren(node) { + return typeof node === 'object' && node.children || []; +} + +// get the name of the tag' +// getName: ( elem:ElementNode ) => tagName:String +function getName(elem) { + return elem.tag; +} + +// get the text content of the node, and its children if it has any +// getText: ( node:Node ) => text:String +// returns empty string when there is no text +function getText(_node) { + return ''; +} + +// get the attribute value +// getAttributeValue: ( elem:ElementNode, name:String ) => value:String +// returns null when attribute doesn't exist +function getAttributeValue(elem, name) { + return elem.props[name] || null; +} + +// takes an array of nodes, and removes any duplicates, as well as any nodes +// whose ancestors are also in the array +function removeSubsets(nodes) { + let idx = nodes.length; + let node; + let ancestor; + let replace; + + // Check if each node (or one of its ancestors) is already contained in the + // array. + while (--idx > -1) { + node = ancestor = nodes[idx]; + + // Temporarily remove the node under consideration + delete nodes[idx]; + replace = true; + while (ancestor) { + if (nodes.includes(ancestor)) { + replace = false; + nodes.splice(idx, 1); + break; + } + ancestor = typeof ancestor === 'object' && ancestor.parent || null; + } + + // If the node has been found to be unique, re-insert it. + if (replace) { + nodes[idx] = node; + } + } + return nodes; +} + +// does at least one of passed element nodes pass the test predicate? +function existsOne(predicate, elems) { + return elems.some(elem => typeof elem === 'object' && (predicate(elem) || existsOne(predicate, elem.children))); +} + +/* + get the siblings of the node. Note that unlike jQuery's `siblings` method, + this is expected to include the current node as well +*/ +function getSiblings(node) { + const parent = typeof node === 'object' && node.parent; + return parent && parent.children || []; +} + +// does the element have the named attribute? +function hasAttrib(elem, name) { + return Object.prototype.hasOwnProperty.call(elem.props, name); +} + +// finds the first node in the array that matches the test predicate, or one +// of its children +function findOne(predicate, elems) { + let elem = null; + for (let i = 0, l = elems.length; i < l && !elem; i++) { + const node = elems[i]; + if (typeof node === 'string') { + /* empty */ + } else if (predicate(node)) { + elem = node; + } else { + const { + children + } = node; + if (children.length !== 0) { + elem = findOne(predicate, children); + } + } + } + return elem; +} + +// finds all of the element nodes in the array that match the test predicate, +// as well as any of their children that match it +function findAll(predicate, nodes, result = []) { + for (let i = 0, j = nodes.length; i < j; i++) { + const node = nodes[i]; + if (typeof node !== 'object') { + continue; + } + if (predicate(node)) { + result.push(node); + } + const { + children + } = node; + if (children.length !== 0) { + findAll(predicate, children, result); + } + } + return result; +} +const cssSelectOpts = { + xmlMode: true, + adapter: { + removeSubsets, + existsOne, + getSiblings, + hasAttrib, + findOne, + findAll, + isTag, + getParent, + getChildren, + getName, + getText, + getAttributeValue + } +}; +/** + * Flatten a CSS AST to a selectors list. + * + * @param {Object} cssAst css-tree AST to flatten + * @param {Array} selectors + */ +function flattenToSelectors(cssAst, selectors) { + _cssTree.default.walk(cssAst, { + visit: 'Rule', + enter(rule) { + const { + type, + prelude + } = rule; + if (type !== 'Rule') { + return; + } + const atrule = this.atrule; + prelude.children.each((node, item) => { + const { + children + } = node; + const pseudos = []; + selectors.push({ + item, + atrule, + rule, + pseudos + }); + children.each(({ + type: childType + }, pseudoItem, list) => { + if (childType === 'PseudoClassSelector' || childType === 'PseudoElementSelector') { + pseudos.push({ + item: pseudoItem, + list + }); + } + }); + }); + } + }); +} + +/** + * Filter selectors by Media Query. + * + * @param {Array} selectors to filter + * @return {Array} Filtered selectors that match the passed media queries + */ +function filterByMqs(selectors) { + return selectors.filter(({ + atrule + }) => { + if (atrule === null) { + return true; + } + const { + name, + prelude + } = atrule; + const atPrelude = prelude; + const first = atPrelude && atPrelude.children.first(); + const mq = first && first.type === 'MediaQueryList'; + const query = mq ? _cssTree.default.generate(atPrelude) : name; + return useMqs.includes(query); + }); +} +// useMqs Array with strings of media queries that should pass ( ) +const useMqs = ['', 'screen']; + +/** + * Filter selectors by the pseudo-elements and/or -classes they contain. + * + * @param {Array} selectors to filter + * @return {Array} Filtered selectors that match the passed pseudo-elements and/or -classes + */ +function filterByPseudos(selectors) { + return selectors.filter(({ + pseudos + }) => usePseudos.includes(_cssTree.default.generate({ + type: 'Selector', + children: new _cssTree.List().fromArray(pseudos.map(pseudo => pseudo.item.data)) + }))); +} +// usePseudos Array with strings of single or sequence of pseudo-elements and/or -classes that should pass +const usePseudos = ['']; + +/** + * Remove pseudo-elements and/or -classes from the selectors for proper matching. + * + * @param {Array} selectors to clean + * @return {Array} Selectors without pseudo-elements and/or -classes + */ +function cleanPseudos(selectors) { + selectors.forEach(({ + pseudos + }) => pseudos.forEach(pseudo => pseudo.list.remove(pseudo.item))); +} +function specificity(selector) { + let A = 0; + let B = 0; + let C = 0; + selector.children.each(function walk(node) { + switch (node.type) { + case 'SelectorList': + case 'Selector': + node.children.each(walk); + break; + case 'IdSelector': + A++; + break; + case 'ClassSelector': + case 'AttributeSelector': + B++; + break; + case 'PseudoClassSelector': + switch (node.name.toLowerCase()) { + case 'not': + { + const children = node.children; + children && children.each(walk); + break; + } + case 'before': + case 'after': + case 'first-line': + case 'first-letter': + C++; + break; + + // TODO: support for :nth-*(.. of ), :matches(), :has() + + default: + B++; + } + break; + case 'PseudoElementSelector': + C++; + break; + case 'TypeSelector': + { + // ignore universal selector + const { + name + } = node; + if (name.charAt(name.length - 1) !== '*') { + C++; + } + break; + } + } + }); + return [A, B, C]; +} + +/** + * Compares two selector specificities. + * extracted from https://github.com/keeganstreet/specificity/blob/master/specificity.js#L211 + * + * @param {Array} aSpecificity Specificity of selector A + * @param {Array} bSpecificity Specificity of selector B + * @return {Number} Score of selector specificity A compared to selector specificity B + */ +function compareSpecificity(aSpecificity, bSpecificity) { + for (let i = 0; i < 4; i += 1) { + if (aSpecificity[i] < bSpecificity[i]) { + return -1; + } else if (aSpecificity[i] > bSpecificity[i]) { + return 1; + } + } + return 0; +} +function selectorWithSpecificity(selector) { + return { + selector, + specificity: specificity(selector.item.data) + }; +} + +/** + * Compare two simple selectors. + * + * @param {Object} a Simple selector A + * @param {Object} b Simple selector B + * @return {Number} Score of selector A compared to selector B + */ +function bySelectorSpecificity(a, b) { + return compareSpecificity(a.specificity, b.specificity); +} + +// Run a single pass with the given chunk size. +function pass(arr, len, chk, result) { + // Step size / double chunk size. + const dbl = chk * 2; + // Bounds of the left and right chunks. + let l, r, e; + // Iterators over the left and right chunk. + let li, ri; + + // Iterate over pairs of chunks. + let i = 0; + for (l = 0; l < len; l += dbl) { + r = l + chk; + e = r + chk; + if (r > len) { + r = len; + } + if (e > len) { + e = len; + } + + // Iterate both chunks in parallel. + li = l; + ri = r; + while (true) { + // Compare the chunks. + if (li < r && ri < e) { + // This works for a regular `sort()` compatible comparator, + // but also for a simple comparator like: `a > b` + if (bySelectorSpecificity(arr[li], arr[ri]) <= 0) { + result[i++] = arr[li++]; + } else { + result[i++] = arr[ri++]; + } + } + // Nothing to compare, just flush what's left. + else if (li < r) { + result[i++] = arr[li++]; + } else if (ri < e) { + result[i++] = arr[ri++]; + } + // Both iterators are at the chunk ends. + else { + break; + } + } + } +} + +// Execute the sort using the input array and a second buffer as work space. +// Returns one of those two, containing the final result. +function exec(arr, len) { + // Rather than dividing input, simply iterate chunks of 1, 2, 4, 8, etc. + // Chunks are the size of the left or right hand in merge sort. + // Stop when the left-hand covers all of the array. + let buffer = new Array(len); + for (let chk = 1; chk < len; chk *= 2) { + pass(arr, len, chk, buffer); + const tmp = arr; + arr = buffer; + buffer = tmp; + } + return arr; +} + +/** + * Sort selectors stably by their specificity. + * + * @param {Array} selectors to be sorted + * @return {Array} Stable sorted selectors + */ +function sortSelectors(selectors) { + // Short-circuit when there's nothing to sort. + const len = selectors.length; + if (len <= 1) { + return selectors; + } + const specs = selectors.map(selectorWithSpecificity); + return exec(specs, len).map(s => s.selector); +} +const declarationParseProps = { + context: 'declarationList', + parseValue: false +}; +function CSSStyleDeclaration(ast) { + const { + props, + styles + } = ast; + if (!props.style) { + props.style = {}; + } + const style = props.style; + const priority = new Map(); + ast.style = style; + ast.priority = priority; + if (!styles || styles.length === 0) { + return; + } + try { + const declarations = _cssTree.default.parse(styles, declarationParseProps); + declarations.children.each(node => { + try { + const { + property, + value, + important + } = node; + const name = property.trim(); + priority.set(name, important); + style[(0, _reactNativeSvg.camelCase)(name)] = _cssTree.default.generate(value).trim(); + } catch (styleError) { + if (styleError instanceof Error && styleError.message !== 'Unknown node type: undefined') { + console.warn("Warning: Parse error when parsing inline styles, style properties of this element cannot be used. The raw styles can still be get/set using .attr('style').value. Error details: " + styleError); + } + } + }); + } catch (parseError) { + console.warn("Warning: Parse error when parsing inline styles, style properties of this element cannot be used. The raw styles can still be get/set using .attr('style').value. Error details: " + parseError); + } +} +function initStyle(selectedEl) { + if (!selectedEl.style) { + CSSStyleDeclaration(selectedEl); + } + return selectedEl; +} + +/** + * Find the closest ancestor of the current element. + * @param node + * @param elemName + * @return {?Object} + */ +function closestElem(node, elemName) { + let elem = node; + while ((elem = elem.parent) && elem.tag !== elemName) { + /* empty */ + } + return elem; +} +const parseProps = { + parseValue: false, + parseCustomProperty: false +}; + +/** + * Moves + merges styles from style elements to element styles + * + * Options + * useMqs (default: ['', 'screen']) + * what media queries to be used + * empty string element for styles outside media queries + * + * usePseudos (default: ['']) + * what pseudo-classes/-elements to be used + * empty string element for all non-pseudo-classes and/or -elements + * + * @param {Object} document document element + * + * @author strarsis + * @author modified by: msand + */ + +function extractVariables(stylesheet) { + const variables = new Map(); + _cssTree.default.walk(stylesheet, { + visit: 'Declaration', + enter(node) { + const { + property, + value + } = node; + if (property.startsWith('--')) { + const variableName = property.trim(); + const variableValue = _cssTree.default.generate(value).trim(); + variables.set(variableName, variableValue); + } + } + }); + return variables; +} +function resolveVariables(value, variables) { + if (value === undefined) { + return ''; + } + const valueStr = typeof value === 'string' ? value : _cssTree.default.generate(value); + return valueStr.replace(/var\((--[^,)]+)(?:,\s*([^)]+))?\)/g, (_, variableName, fallback) => { + const resolvedValue = variables.get(variableName); + if (resolvedValue !== undefined) { + return resolveVariables(resolvedValue, variables); + } + return fallback ? resolveVariables(fallback, variables) : ''; + }); +} +const propsToResolve = ['color', 'fill', 'floodColor', 'lightingColor', 'stopColor', 'stroke']; +const resolveElementVariables = (element, variables) => propsToResolve.forEach(prop => { + const value = element.props[prop]; + if (value && value.startsWith('var(')) { + element.props[prop] = resolveVariables(value, variables); + } +}); +const inlineStyles = exports.inlineStyles = function inlineStyles(document) { + // collect