@tamagui/linear-gradient 1.108.4 → 1.109.1

package/dist/cjs/LinearGradient.js

@@ -2,14 +2,56 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
   if (from && typeof from == "object" || typeof from == "function")
     for (let key of __getOwnPropNames(from))
       !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
-}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+};
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var LinearGradient_exports = {};
+__export(LinearGradient_exports, {
+  LinearGradient: () => LinearGradient
+});
 module.exports = __toCommonJS(LinearGradient_exports);
-__reExport(LinearGradient_exports, require("./LinearGradient-shared"), module.exports);
+var import_core = require("@tamagui/core"), import_stacks = require("@tamagui/stacks"), import_linear_gradient = require("./linear-gradient"), import_jsx_runtime = require("react/jsx-runtime");
+const LinearGradientFrame = (0, import_core.styled)(import_stacks.YStack, {
+  name: "LinearGradient",
+  overflow: "hidden",
+  position: "relative"
+}), LinearGradient = LinearGradientFrame.styleable(
+  (propsIn, ref) => {
+    const props = (0, import_core.useProps)(propsIn), { start, end, colors: colorsProp, locations, children, ...stackProps } = props, theme = (0, import_core.useTheme)();
+    let colors = props.colors?.map((c) => theme[c]?.get("web") ?? c) || [];
+    return process.env.NODE_ENV !== "production" && colors.some((c) => {
+      const normalized = (0, import_core.normalizeColor)(c);
+      if (!normalized || normalized.startsWith("$"))
+        return !0;
+    }) && (console.error(
+      `LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`
+    ), colors = ["#000", "#fff"]), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(LinearGradientFrame, { ref, ...stackProps, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_linear_gradient.LinearGradient,
+        {
+          start,
+          end,
+          colors,
+          locations,
+          style: gradientStyle
+        }
+      ),
+      children
+    ] });
+  }
+), gradientStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0
+};
 //# sourceMappingURL=LinearGradient.js.map

package/dist/cjs/LinearGradient.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/LinearGradient.tsx"],
-  "mappings": ";;;;;;;;;;;AAAA;AAAA;AAAA,mCAAc,oCAAd;",
-  "names": []
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAA2D,0BAC3D,gBAAuB,4BAIvB,yBAAqD,8BA6C/C;AAnCN,MAAM,0BAAsB,oBAAO,sBAAQ;AAAA,EACzC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AACZ,CAAC,GAEY,iBAAiB,oBAAoB;AAAA,EAChD,CAAC,SAAS,QAAQ;AAChB,UAAM,YAAQ,sBAAS,OAAO,GAExB,EAAE,OAAO,KAAK,QAAQ,YAAY,WAAW,UAAU,GAAG,WAAW,IAAI,OACzE,YAAQ,sBAAS;AAEvB,QAAI,SACF,MAAM,QAAQ,IAAI,CAAC,MACT,MAAM,CAAC,GAAG,IAAI,KAAK,KAAgB,CAC5C,KAAK,CAAC;AAET,WAAI,QAAQ,IAAI,aAAa,gBAEzB,OAAO,KAAK,CAAC,MAAM;AACjB,YAAM,iBAAa,4BAAe,CAAC;AACnC,UAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C,eAAO;AAAA,IAEX,CAAC,MAED,QAAQ;AAAA,MACN,gEAAgE,MAAM;AAAA,IACxE,GACA,SAAS,CAAC,QAAQ,MAAM,IAK1B,6CAAC,uBAAoB,KAAkB,GAAG,YACxC;AAAA;AAAA,QAAC,uBAAAA;AAAA,QAAA;AAAA,UACC;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,OAAO;AAAA;AAAA,MACT;AAAA,MACC;AAAA,OACH;AAAA,EAEJ;AACF,GAIM,gBAA2B;AAAA,EAC/B,UAAU;AAAA,EACV,KAAK;AAAA,EACL,MAAM;AAAA,EACN,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AACV;",
+  "names": ["ExpoLinearGradient"]
 }

package/dist/cjs/LinearGradient.native.js

@@ -13,12 +13,12 @@ var __export = (target, all) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var LinearGradient_native_exports = {};
-__export(LinearGradient_native_exports, {
+var LinearGradient_exports = {};
+__export(LinearGradient_exports, {
   LinearGradient: () => LinearGradient
 });
-module.exports = __toCommonJS(LinearGradient_native_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
+module.exports = __toCommonJS(LinearGradient_exports);
+var import_jsx_runtime = require("react/jsx-runtime"), import_core = require("@tamagui/core"), import_stacks = require("@tamagui/stacks"), import_linear_gradient = require("./linear-gradient");
 function _define_property(obj, key, value) {
   return key in obj ? Object.defineProperty(obj, key, {
     value,
@@ -29,21 +29,93 @@ function _define_property(obj, key, value) {
 }
 function _object_spread(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {}, ownKeys = Object.keys(source);
-    typeof Object.getOwnPropertySymbols == "function" && (ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
       return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-    }))), ownKeys.forEach(function(key) {
+    }))), ownKeys2.forEach(function(key) {
       _define_property(target, key, source[key]);
     });
   }
   return target;
 }
-function LinearGradient(props) {
-  var Real = require("./LinearGradient-shared").LinearGradient;
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Real, _object_spread({}, props));
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _object_without_properties(source, excluded) {
+  if (source == null) return {};
+  var target = _object_without_properties_loose(source, excluded), key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++)
+      key = sourceSymbolKeys[i], !(excluded.indexOf(key) >= 0) && Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+}
+function _object_without_properties_loose(source, excluded) {
+  if (source == null) return {};
+  var target = {}, sourceKeys = Object.keys(source), key, i;
+  for (i = 0; i < sourceKeys.length; i++)
+    key = sourceKeys[i], !(excluded.indexOf(key) >= 0) && (target[key] = source[key]);
+  return target;
 }
+var LinearGradientFrame = (0, import_core.styled)(import_stacks.YStack, {
+  name: "LinearGradient",
+  overflow: "hidden",
+  position: "relative"
+}), LinearGradient = LinearGradientFrame.styleable(function(propsIn, ref) {
+  var _props_colors, props = (0, import_core.useProps)(propsIn), start = props.start, end = props.end, colorsProp = props.colors, locations = props.locations, children = props.children, stackProps = _object_without_properties(props, [
+    "start",
+    "end",
+    "colors",
+    "locations",
+    "children"
+  ]), theme = (0, import_core.useTheme)(), colors = ((_props_colors = props.colors) === null || _props_colors === void 0 ? void 0 : _props_colors.map(function(c) {
+    var _theme_c, _theme_c_get;
+    return (_theme_c_get = (_theme_c = theme[c]) === null || _theme_c === void 0 ? void 0 : _theme_c.get("web")) !== null && _theme_c_get !== void 0 ? _theme_c_get : c;
+  })) || [];
+  return process.env.NODE_ENV !== "production" && colors.some(function(c) {
+    var normalized = (0, import_core.normalizeColor)(c);
+    if (!normalized || normalized.startsWith("$"))
+      return !0;
+  }) && (console.error('LinearGradient: "colors" prop contains invalid color tokens: '.concat(colors, ' fallback to default colors: ["#000", "#fff"]')), colors = [
+    "#000",
+    "#fff"
+  ]), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(LinearGradientFrame, _object_spread_props(_object_spread({
+    ref
+  }, stackProps), {
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_linear_gradient.LinearGradient, {
+        start,
+        end,
+        colors,
+        locations,
+        style: gradientStyle
+      }),
+      children
+    ]
+  }));
+}), gradientStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LinearGradient
 });
-//# sourceMappingURL=LinearGradient.native.js.map
+//# sourceMappingURL=LinearGradient.js.map

package/dist/cjs/LinearGradient.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/Users/n8/tamagui/code/ui/linear-gradient/src/LinearGradient.native.tsx"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;;AAGC,SAAA,iBAAA,KAAA,KAAA,OAAA;;;;;;;;;;;;;;;;;;;AAEM,SAASA,eAAeC,OAAK;AAClC,MAAMC,OAAOC,QAAQ,yBAAA,EAA2BH;AAChD,SAAO,uCAAAI,KAACF,MAAAA,eAAAA,CAAAA,GAASD,KAAAA,CAAAA;AACnB;",
-  "names": ["LinearGradient", "props", "Real", "require", "_jsx"]
+  "sources": ["../../src/Users/n8/tamagui/code/ui/linear-gradient/src/LinearGradient.tsx"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;uDACA,cAA2D,0BAC3D,gBAAuB,4BAIvB,yBAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUrD,IAAMA,0BAAsBC,oBAAOC,sBAAQ;EACzCC,MAAM;EACNC,UAAU;EACVC,UAAU;AACZ,CAAA,GAEaC,iBAAiBN,oBAAoBO,UAChD,SAACC,SAASC,KAAAA;MAONC,eANIA,YAAQC,sBAASH,OAAAA,GAEfI,QAAuEF,MAAvEE,OAAOC,MAAgEH,MAAhEG,KAAaC,aAAmDJ,MAA3DK,QAAoBC,YAAuCN,MAAvCM,WAAWC,WAA4BP,MAA5BO,UAAaC,aAAAA,2BAAeR,OAAAA;IAAvEE;IAAOC;IAAKE;IAAoBC;IAAWC;MAC7CE,YAAQC,sBAAAA,GAEVL,WACFL,gBAAAA,MAAMK,YAAM,QAAZL,kBAAAA,SAAAA,SAAAA,cAAcW,IAAI,SAACC,GAAAA;QACTH,UAAAA;AAAR,YAAQA,gBAAAA,WAAAA,MAAMG,CAAAA,OAAE,QAARH,aAAAA,SAAAA,SAAAA,SAAUI,IAAI,KAAA,OAAA,QAAdJ,iBAAAA,SAAAA,eAAmCG;EAC7C,CAAA,MAAM,CAAA;AAER,SAAIE,QAAQC,IAAIC,aAAa,gBAEzBX,OAAOY,KAAK,SAACL,GAAAA;AACX,QAAMM,iBAAaC,4BAAeP,CAAAA;AAClC,QAAI,CAACM,cAAcA,WAAWE,WAAW,GAAA;AACvC,aAAO;EAEX,CAAA,MAEAC,QAAQC,MACL,gEAAsE,OAAPjB,QAAO,+CAAA,CAAA,GAEzEA,SAAS;IAAC;IAAQ;MAKpB,uCAAAkB,MAACjC,qBAAAA,qBAAAA,eAAAA;IAAoBS;KAAqBS,UAAAA,GAAAA;;MACxC,uCAAAgB,KAACC,uBAAAA,gBAAAA;QACCvB;QACAC;QACAE;QACAC;QACAoB,OAAOC;;MAERpB;;;AAGP,CAAA,GAKIoB,gBAA2B;EAC/BhC,UAAU;EACViC,KAAK;EACLC,MAAM;EACNC,OAAO;EACPC,QAAQ;EACRC,QAAQ;AACV;",
+  "names": ["LinearGradientFrame", "styled", "YStack", "name", "overflow", "position", "LinearGradient", "styleable", "propsIn", "ref", "props", "useProps", "start", "end", "colorsProp", "colors", "locations", "children", "stackProps", "theme", "useTheme", "map", "c", "get", "process", "env", "NODE_ENV", "some", "normalized", "normalizeColor", "startsWith", "console", "error", "_jsxs", "_jsx", "ExpoLinearGradient", "style", "gradientStyle", "top", "left", "right", "bottom", "zIndex"]
 }

package/dist/esm/LinearGradient.js

@@ -1,2 +1,44 @@
-export * from "./LinearGradient-shared";
+import { normalizeColor, styled, useProps, useTheme } from "@tamagui/core";
+import { YStack } from "@tamagui/stacks";
+import { LinearGradient as ExpoLinearGradient } from "./linear-gradient";
+import { jsx, jsxs } from "react/jsx-runtime";
+const LinearGradientFrame = styled(YStack, {
+  name: "LinearGradient",
+  overflow: "hidden",
+  position: "relative"
+}), LinearGradient = LinearGradientFrame.styleable(
+  (propsIn, ref) => {
+    const props = useProps(propsIn), { start, end, colors: colorsProp, locations, children, ...stackProps } = props, theme = useTheme();
+    let colors = props.colors?.map((c) => theme[c]?.get("web") ?? c) || [];
+    return process.env.NODE_ENV !== "production" && colors.some((c) => {
+      const normalized = normalizeColor(c);
+      if (!normalized || normalized.startsWith("$"))
+        return !0;
+    }) && (console.error(
+      `LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`
+    ), colors = ["#000", "#fff"]), /* @__PURE__ */ jsxs(LinearGradientFrame, { ref, ...stackProps, children: [
+      /* @__PURE__ */ jsx(
+        ExpoLinearGradient,
+        {
+          start,
+          end,
+          colors,
+          locations,
+          style: gradientStyle
+        }
+      ),
+      children
+    ] });
+  }
+), gradientStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0
+};
+export {
+  LinearGradient
+};
 //# sourceMappingURL=LinearGradient.js.map

package/dist/esm/LinearGradient.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/LinearGradient.tsx"],
-  "mappings": "AAAA,cAAc;",
+  "mappings": "AACA,SAAS,gBAAgB,QAAQ,UAAU,gBAAgB;AAC3D,SAAS,cAAc;AAIvB,SAAS,kBAAkB,0BAA0B;AA6C/C,SACE,KADF;AAnCN,MAAM,sBAAsB,OAAO,QAAQ;AAAA,EACzC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AACZ,CAAC,GAEY,iBAAiB,oBAAoB;AAAA,EAChD,CAAC,SAAS,QAAQ;AAChB,UAAM,QAAQ,SAAS,OAAO,GAExB,EAAE,OAAO,KAAK,QAAQ,YAAY,WAAW,UAAU,GAAG,WAAW,IAAI,OACzE,QAAQ,SAAS;AAEvB,QAAI,SACF,MAAM,QAAQ,IAAI,CAAC,MACT,MAAM,CAAC,GAAG,IAAI,KAAK,KAAgB,CAC5C,KAAK,CAAC;AAET,WAAI,QAAQ,IAAI,aAAa,gBAEzB,OAAO,KAAK,CAAC,MAAM;AACjB,YAAM,aAAa,eAAe,CAAC;AACnC,UAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C,eAAO;AAAA,IAEX,CAAC,MAED,QAAQ;AAAA,MACN,gEAAgE,MAAM;AAAA,IACxE,GACA,SAAS,CAAC,QAAQ,MAAM,IAK1B,qBAAC,uBAAoB,KAAkB,GAAG,YACxC;AAAA;AAAA,QAAC;AAAA;AAAA,UACC;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,OAAO;AAAA;AAAA,MACT;AAAA,MACC;AAAA,OACH;AAAA,EAEJ;AACF,GAIM,gBAA2B;AAAA,EAC/B,UAAU;AAAA,EACV,KAAK;AAAA,EACL,MAAM;AAAA,EACN,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AACV;",
   "names": []
 }

package/dist/esm/LinearGradient.mjs

@@ -1,2 +1,46 @@
-export * from "./LinearGradient-shared.mjs";
+import { normalizeColor, styled, useProps, useTheme } from "@tamagui/core";
+import { YStack } from "@tamagui/stacks";
+import { LinearGradient as ExpoLinearGradient } from "./linear-gradient.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+const LinearGradientFrame = styled(YStack, {
+    name: "LinearGradient",
+    overflow: "hidden",
+    position: "relative"
+  }),
+  LinearGradient = LinearGradientFrame.styleable((propsIn, ref) => {
+    const props = useProps(propsIn),
+      {
+        start,
+        end,
+        colors: colorsProp,
+        locations,
+        children,
+        ...stackProps
+      } = props,
+      theme = useTheme();
+    let colors = props.colors?.map(c => theme[c]?.get("web") ?? c) || [];
+    return process.env.NODE_ENV !== "production" && colors.some(c => {
+      const normalized = normalizeColor(c);
+      if (!normalized || normalized.startsWith("$")) return !0;
+    }) && (console.error(`LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`), colors = ["#000", "#fff"]), /* @__PURE__ */jsxs(LinearGradientFrame, {
+      ref,
+      ...stackProps,
+      children: [/* @__PURE__ */jsx(ExpoLinearGradient, {
+        start,
+        end,
+        colors,
+        locations,
+        style: gradientStyle
+      }), children]
+    });
+  }),
+  gradientStyle = {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    zIndex: 0
+  };
+export { LinearGradient };
 //# sourceMappingURL=LinearGradient.mjs.map

package/dist/esm/LinearGradient.mjs.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["../../src/LinearGradient.tsx"],"sourcesContent":[null],"mappings":"AAAA,cAAc","ignoreList":[]}
+{"version":3,"names":["normalizeColor","styled","useProps","useTheme","YStack","LinearGradient","ExpoLinearGradient","jsx","jsxs","LinearGradientFrame","name","overflow","position","styleable","propsIn","ref","props","start","end","colors","colorsProp","locations","children","stackProps","theme","map","c","get","process","env","NODE_ENV","some","normalized","startsWith","console","error","style","gradientStyle","top","left","right","bottom","zIndex"],"sources":["../../src/LinearGradient.tsx"],"sourcesContent":[null],"mappings":"AACA,SAASA,cAAA,EAAgBC,MAAA,EAAQC,QAAA,EAAUC,QAAA,QAAgB;AAC3D,SAASC,MAAA,QAAc;AAIvB,SAASC,cAAA,IAAkBC,kBAAA,QAA0B;AA6C/C,SACEC,GAAA,EADFC,IAAA;AAnCN,MAAMC,mBAAA,GAAsBR,MAAA,CAAOG,MAAA,EAAQ;IACzCM,IAAA,EAAM;IACNC,QAAA,EAAU;IACVC,QAAA,EAAU;EACZ,CAAC;EAEYP,cAAA,GAAiBI,mBAAA,CAAoBI,SAAA,CAChD,CAACC,OAAA,EAASC,GAAA,KAAQ;IAChB,MAAMC,KAAA,GAAQd,QAAA,CAASY,OAAO;MAExB;QAAEG,KAAA;QAAOC,GAAA;QAAKC,MAAA,EAAQC,UAAA;QAAYC,SAAA;QAAWC,QAAA;QAAU,GAAGC;MAAW,IAAIP,KAAA;MACzEQ,KAAA,GAAQrB,QAAA,CAAS;IAEvB,IAAIgB,MAAA,GACFH,KAAA,CAAMG,MAAA,EAAQM,GAAA,CAAKC,CAAA,IACTF,KAAA,CAAME,CAAC,GAAGC,GAAA,CAAI,KAAK,KAAgBD,CAC5C,KAAK,EAAC;IAET,OAAIE,OAAA,CAAQC,GAAA,CAAIC,QAAA,KAAa,gBAEzBX,MAAA,CAAOY,IAAA,CAAML,CAAA,IAAM;MACjB,MAAMM,UAAA,GAAahC,cAAA,CAAe0B,CAAC;MACnC,IAAI,CAACM,UAAA,IAAcA,UAAA,CAAWC,UAAA,CAAW,GAAG,GAC1C,OAAO;IAEX,CAAC,MAEDC,OAAA,CAAQC,KAAA,CACN,gEAAgEhB,MAAM,+CACxE,GACAA,MAAA,GAAS,CAAC,QAAQ,MAAM,IAK1B,eAAAX,IAAA,CAACC,mBAAA;MAAoBM,GAAA;MAAkB,GAAGQ,UAAA;MACxCD,QAAA,kBAAAf,GAAA,CAACD,kBAAA;QACCW,KAAA;QACAC,GAAA;QACAC,MAAA;QACAE,SAAA;QACAe,KAAA,EAAOC;MAAA,CACT,GACCf,QAAA;IAAA,CACH;EAEJ,CACF;EAIMe,aAAA,GAA2B;IAC/BzB,QAAA,EAAU;IACV0B,GAAA,EAAK;IACLC,IAAA,EAAM;IACNC,KAAA,EAAO;IACPC,MAAA,EAAQ;IACRC,MAAA,EAAQ;EACV","ignoreList":[]}

package/dist/esm/LinearGradient.native.js

@@ -1,4 +1,7 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { normalizeColor, styled, useProps, useTheme } from "@tamagui/core";
+import { YStack } from "@tamagui/stacks";
+import { LinearGradient as ExpoLinearGradient } from "./linear-gradient";
 function _define_property(obj, key, value) {
   return key in obj ? Object.defineProperty(obj, key, {
     value,
@@ -9,20 +12,92 @@ function _define_property(obj, key, value) {
 }
 function _object_spread(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {}, ownKeys = Object.keys(source);
-    typeof Object.getOwnPropertySymbols == "function" && (ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
       return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-    }))), ownKeys.forEach(function(key) {
+    }))), ownKeys2.forEach(function(key) {
       _define_property(target, key, source[key]);
     });
   }
   return target;
 }
-function LinearGradient(props) {
-  var Real = require("./LinearGradient-shared").LinearGradient;
-  return /* @__PURE__ */ _jsx(Real, _object_spread({}, props));
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _object_without_properties(source, excluded) {
+  if (source == null) return {};
+  var target = _object_without_properties_loose(source, excluded), key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++)
+      key = sourceSymbolKeys[i], !(excluded.indexOf(key) >= 0) && Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+}
+function _object_without_properties_loose(source, excluded) {
+  if (source == null) return {};
+  var target = {}, sourceKeys = Object.keys(source), key, i;
+  for (i = 0; i < sourceKeys.length; i++)
+    key = sourceKeys[i], !(excluded.indexOf(key) >= 0) && (target[key] = source[key]);
+  return target;
 }
+var LinearGradientFrame = styled(YStack, {
+  name: "LinearGradient",
+  overflow: "hidden",
+  position: "relative"
+}), LinearGradient = LinearGradientFrame.styleable(function(propsIn, ref) {
+  var _props_colors, props = useProps(propsIn), start = props.start, end = props.end, colorsProp = props.colors, locations = props.locations, children = props.children, stackProps = _object_without_properties(props, [
+    "start",
+    "end",
+    "colors",
+    "locations",
+    "children"
+  ]), theme = useTheme(), colors = ((_props_colors = props.colors) === null || _props_colors === void 0 ? void 0 : _props_colors.map(function(c) {
+    var _theme_c, _theme_c_get;
+    return (_theme_c_get = (_theme_c = theme[c]) === null || _theme_c === void 0 ? void 0 : _theme_c.get("web")) !== null && _theme_c_get !== void 0 ? _theme_c_get : c;
+  })) || [];
+  return process.env.NODE_ENV !== "production" && colors.some(function(c) {
+    var normalized = normalizeColor(c);
+    if (!normalized || normalized.startsWith("$"))
+      return !0;
+  }) && (console.error('LinearGradient: "colors" prop contains invalid color tokens: '.concat(colors, ' fallback to default colors: ["#000", "#fff"]')), colors = [
+    "#000",
+    "#fff"
+  ]), /* @__PURE__ */ _jsxs(LinearGradientFrame, _object_spread_props(_object_spread({
+    ref
+  }, stackProps), {
+    children: [
+      /* @__PURE__ */ _jsx(ExpoLinearGradient, {
+        start,
+        end,
+        colors,
+        locations,
+        style: gradientStyle
+      }),
+      children
+    ]
+  }));
+}), gradientStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0
+};
 export {
   LinearGradient
 };
-//# sourceMappingURL=LinearGradient.native.js.map
+//# sourceMappingURL=LinearGradient.js.map

package/dist/esm/LinearGradient.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/Users/n8/tamagui/code/ui/linear-gradient/src/LinearGradient.native.tsx"],
-  "mappings": ";AAGC,SAAA,iBAAA,KAAA,KAAA,OAAA;;;;;;;;;;;;;;;;;;;AAEM,SAASA,eAAeC,OAAK;AAClC,MAAMC,OAAOC,QAAQ,yBAAA,EAA2BH;AAChD,SAAO,qBAACE,MAAAA,eAAAA,CAAAA,GAASD,KAAAA,CAAAA;AACnB;",
-  "names": ["LinearGradient", "props", "Real", "require"]
+  "sources": ["../../src/Users/n8/tamagui/code/ui/linear-gradient/src/LinearGradient.tsx"],
+  "mappings": ";AACA,SAASA,gBAAgBC,QAAQC,UAAUC,gBAAgB;AAC3D,SAASC,cAAc;AAIvB,SAASC,kBAAkBC,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUrD,IAAMC,sBAAsBN,OAAOG,QAAQ;EACzCI,MAAM;EACNC,UAAU;EACVC,UAAU;AACZ,CAAA,GAEaL,iBAAiBE,oBAAoBI,UAChD,SAACC,SAASC,KAAAA;MAONC,eANIA,QAAQZ,SAASU,OAAAA,GAEfG,QAAuED,MAAvEC,OAAOC,MAAgEF,MAAhEE,KAAaC,aAAmDH,MAA3DI,QAAoBC,YAAuCL,MAAvCK,WAAWC,WAA4BN,MAA5BM,UAAaC,aAAAA,2BAAeP,OAAAA;IAAvEC;IAAOC;IAAKE;IAAoBC;IAAWC;MAC7CE,QAAQnB,SAAAA,GAEVe,WACFJ,gBAAAA,MAAMI,YAAM,QAAZJ,kBAAAA,SAAAA,SAAAA,cAAcS,IAAI,SAACC,GAAAA;QACTF,UAAAA;AAAR,YAAQA,gBAAAA,WAAAA,MAAME,CAAAA,OAAE,QAARF,aAAAA,SAAAA,SAAAA,SAAUG,IAAI,KAAA,OAAA,QAAdH,iBAAAA,SAAAA,eAAmCE;EAC7C,CAAA,MAAM,CAAA;AAER,SAAIE,QAAQC,IAAIC,aAAa,gBAEzBV,OAAOW,KAAK,SAACL,GAAAA;AACX,QAAMM,aAAa9B,eAAewB,CAAAA;AAClC,QAAI,CAACM,cAAcA,WAAWC,WAAW,GAAA;AACvC,aAAO;EAEX,CAAA,MAEAC,QAAQC,MACL,gEAAsE,OAAPf,QAAO,+CAAA,CAAA,GAEzEA,SAAS;IAAC;IAAQ;MAKpB,sBAACX,qBAAAA,qBAAAA,eAAAA;IAAoBM;KAAqBQ,UAAAA,GAAAA;;MACxC,qBAACf,oBAAAA;QACCS;QACAC;QACAE;QACAC;QACAe,OAAOC;;MAERf;;;AAGP,CAAA,GAKIe,gBAA2B;EAC/BzB,UAAU;EACV0B,KAAK;EACLC,MAAM;EACNC,OAAO;EACPC,QAAQ;EACRC,QAAQ;AACV;",
+  "names": ["normalizeColor", "styled", "useProps", "useTheme", "YStack", "LinearGradient", "ExpoLinearGradient", "LinearGradientFrame", "name", "overflow", "position", "styleable", "propsIn", "ref", "props", "start", "end", "colorsProp", "colors", "locations", "children", "stackProps", "theme", "map", "c", "get", "process", "env", "NODE_ENV", "some", "normalized", "startsWith", "console", "error", "style", "gradientStyle", "top", "left", "right", "bottom", "zIndex"]
 }

package/dist/jsx/LinearGradient.js

@@ -1,2 +1,44 @@
-export * from "./LinearGradient-shared";
+import { normalizeColor, styled, useProps, useTheme } from "@tamagui/core";
+import { YStack } from "@tamagui/stacks";
+import { LinearGradient as ExpoLinearGradient } from "./linear-gradient";
+import { jsx, jsxs } from "react/jsx-runtime";
+const LinearGradientFrame = styled(YStack, {
+  name: "LinearGradient",
+  overflow: "hidden",
+  position: "relative"
+}), LinearGradient = LinearGradientFrame.styleable(
+  (propsIn, ref) => {
+    const props = useProps(propsIn), { start, end, colors: colorsProp, locations, children, ...stackProps } = props, theme = useTheme();
+    let colors = props.colors?.map((c) => theme[c]?.get("web") ?? c) || [];
+    return process.env.NODE_ENV !== "production" && colors.some((c) => {
+      const normalized = normalizeColor(c);
+      if (!normalized || normalized.startsWith("$"))
+        return !0;
+    }) && (console.error(
+      `LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`
+    ), colors = ["#000", "#fff"]), /* @__PURE__ */ jsxs(LinearGradientFrame, { ref, ...stackProps, children: [
+      /* @__PURE__ */ jsx(
+        ExpoLinearGradient,
+        {
+          start,
+          end,
+          colors,
+          locations,
+          style: gradientStyle
+        }
+      ),
+      children
+    ] });
+  }
+), gradientStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0
+};
+export {
+  LinearGradient
+};
 //# sourceMappingURL=LinearGradient.js.map

package/dist/jsx/LinearGradient.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/LinearGradient.tsx"],
-  "mappings": "AAAA,cAAc;",
+  "mappings": "AACA,SAAS,gBAAgB,QAAQ,UAAU,gBAAgB;AAC3D,SAAS,cAAc;AAIvB,SAAS,kBAAkB,0BAA0B;AA6C/C,SACE,KADF;AAnCN,MAAM,sBAAsB,OAAO,QAAQ;AAAA,EACzC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AACZ,CAAC,GAEY,iBAAiB,oBAAoB;AAAA,EAChD,CAAC,SAAS,QAAQ;AAChB,UAAM,QAAQ,SAAS,OAAO,GAExB,EAAE,OAAO,KAAK,QAAQ,YAAY,WAAW,UAAU,GAAG,WAAW,IAAI,OACzE,QAAQ,SAAS;AAEvB,QAAI,SACF,MAAM,QAAQ,IAAI,CAAC,MACT,MAAM,CAAC,GAAG,IAAI,KAAK,KAAgB,CAC5C,KAAK,CAAC;AAET,WAAI,QAAQ,IAAI,aAAa,gBAEzB,OAAO,KAAK,CAAC,MAAM;AACjB,YAAM,aAAa,eAAe,CAAC;AACnC,UAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C,eAAO;AAAA,IAEX,CAAC,MAED,QAAQ;AAAA,MACN,gEAAgE,MAAM;AAAA,IACxE,GACA,SAAS,CAAC,QAAQ,MAAM,IAK1B,qBAAC,uBAAoB,KAAkB,GAAG,YACxC;AAAA;AAAA,QAAC;AAAA;AAAA,UACC;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,OAAO;AAAA;AAAA,MACT;AAAA,MACC;AAAA,OACH;AAAA,EAEJ;AACF,GAIM,gBAA2B;AAAA,EAC/B,UAAU;AAAA,EACV,KAAK;AAAA,EACL,MAAM;AAAA,EACN,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AACV;",
   "names": []
 }

package/dist/jsx/LinearGradient.mjs

@@ -1,2 +1,46 @@
-export * from "./LinearGradient-shared.mjs";
+import { normalizeColor, styled, useProps, useTheme } from "@tamagui/core";
+import { YStack } from "@tamagui/stacks";
+import { LinearGradient as ExpoLinearGradient } from "./linear-gradient.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+const LinearGradientFrame = styled(YStack, {
+    name: "LinearGradient",
+    overflow: "hidden",
+    position: "relative"
+  }),
+  LinearGradient = LinearGradientFrame.styleable((propsIn, ref) => {
+    const props = useProps(propsIn),
+      {
+        start,
+        end,
+        colors: colorsProp,
+        locations,
+        children,
+        ...stackProps
+      } = props,
+      theme = useTheme();
+    let colors = props.colors?.map(c => theme[c]?.get("web") ?? c) || [];
+    return process.env.NODE_ENV !== "production" && colors.some(c => {
+      const normalized = normalizeColor(c);
+      if (!normalized || normalized.startsWith("$")) return !0;
+    }) && (console.error(`LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`), colors = ["#000", "#fff"]), /* @__PURE__ */jsxs(LinearGradientFrame, {
+      ref,
+      ...stackProps,
+      children: [/* @__PURE__ */jsx(ExpoLinearGradient, {
+        start,
+        end,
+        colors,
+        locations,
+        style: gradientStyle
+      }), children]
+    });
+  }),
+  gradientStyle = {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    zIndex: 0
+  };
+export { LinearGradient };
 //# sourceMappingURL=LinearGradient.mjs.map

package/dist/jsx/LinearGradient.mjs.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["../../src/LinearGradient.tsx"],"sourcesContent":[null],"mappings":"AAAA,cAAc","ignoreList":[]}
+{"version":3,"names":["normalizeColor","styled","useProps","useTheme","YStack","LinearGradient","ExpoLinearGradient","jsx","jsxs","LinearGradientFrame","name","overflow","position","styleable","propsIn","ref","props","start","end","colors","colorsProp","locations","children","stackProps","theme","map","c","get","process","env","NODE_ENV","some","normalized","startsWith","console","error","style","gradientStyle","top","left","right","bottom","zIndex"],"sources":["../../src/LinearGradient.tsx"],"sourcesContent":[null],"mappings":"AACA,SAASA,cAAA,EAAgBC,MAAA,EAAQC,QAAA,EAAUC,QAAA,QAAgB;AAC3D,SAASC,MAAA,QAAc;AAIvB,SAASC,cAAA,IAAkBC,kBAAA,QAA0B;AA6C/C,SACEC,GAAA,EADFC,IAAA;AAnCN,MAAMC,mBAAA,GAAsBR,MAAA,CAAOG,MAAA,EAAQ;IACzCM,IAAA,EAAM;IACNC,QAAA,EAAU;IACVC,QAAA,EAAU;EACZ,CAAC;EAEYP,cAAA,GAAiBI,mBAAA,CAAoBI,SAAA,CAChD,CAACC,OAAA,EAASC,GAAA,KAAQ;IAChB,MAAMC,KAAA,GAAQd,QAAA,CAASY,OAAO;MAExB;QAAEG,KAAA;QAAOC,GAAA;QAAKC,MAAA,EAAQC,UAAA;QAAYC,SAAA;QAAWC,QAAA;QAAU,GAAGC;MAAW,IAAIP,KAAA;MACzEQ,KAAA,GAAQrB,QAAA,CAAS;IAEvB,IAAIgB,MAAA,GACFH,KAAA,CAAMG,MAAA,EAAQM,GAAA,CAAKC,CAAA,IACTF,KAAA,CAAME,CAAC,GAAGC,GAAA,CAAI,KAAK,KAAgBD,CAC5C,KAAK,EAAC;IAET,OAAIE,OAAA,CAAQC,GAAA,CAAIC,QAAA,KAAa,gBAEzBX,MAAA,CAAOY,IAAA,CAAML,CAAA,IAAM;MACjB,MAAMM,UAAA,GAAahC,cAAA,CAAe0B,CAAC;MACnC,IAAI,CAACM,UAAA,IAAcA,UAAA,CAAWC,UAAA,CAAW,GAAG,GAC1C,OAAO;IAEX,CAAC,MAEDC,OAAA,CAAQC,KAAA,CACN,gEAAgEhB,MAAM,+CACxE,GACAA,MAAA,GAAS,CAAC,QAAQ,MAAM,IAK1B,eAAAX,IAAA,CAACC,mBAAA;MAAoBM,GAAA;MAAkB,GAAGQ,UAAA;MACxCD,QAAA,kBAAAf,GAAA,CAACD,kBAAA;QACCW,KAAA;QACAC,GAAA;QACAC,MAAA;QACAE,SAAA;QACAe,KAAA,EAAOC;MAAA,CACT,GACCf,QAAA;IAAA,CACH;EAEJ,CACF;EAIMe,aAAA,GAA2B;IAC/BzB,QAAA,EAAU;IACV0B,GAAA,EAAK;IACLC,IAAA,EAAM;IACNC,KAAA,EAAO;IACPC,MAAA,EAAQ;IACRC,MAAA,EAAQ;EACV","ignoreList":[]}

package/dist/jsx/LinearGradient.native.js

@@ -1,4 +1,7 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { normalizeColor, styled, useProps, useTheme } from "@tamagui/core";
+import { YStack } from "@tamagui/stacks";
+import { LinearGradient as ExpoLinearGradient } from "./linear-gradient";
 function _define_property(obj, key, value) {
   return key in obj ? Object.defineProperty(obj, key, {
     value,
@@ -9,20 +12,92 @@ function _define_property(obj, key, value) {
 }
 function _object_spread(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {}, ownKeys = Object.keys(source);
-    typeof Object.getOwnPropertySymbols == "function" && (ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
       return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-    }))), ownKeys.forEach(function(key) {
+    }))), ownKeys2.forEach(function(key) {
       _define_property(target, key, source[key]);
     });
   }
   return target;
 }
-function LinearGradient(props) {
-  var Real = require("./LinearGradient-shared").LinearGradient;
-  return /* @__PURE__ */ _jsx(Real, _object_spread({}, props));
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _object_without_properties(source, excluded) {
+  if (source == null) return {};
+  var target = _object_without_properties_loose(source, excluded), key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++)
+      key = sourceSymbolKeys[i], !(excluded.indexOf(key) >= 0) && Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+}
+function _object_without_properties_loose(source, excluded) {
+  if (source == null) return {};
+  var target = {}, sourceKeys = Object.keys(source), key, i;
+  for (i = 0; i < sourceKeys.length; i++)
+    key = sourceKeys[i], !(excluded.indexOf(key) >= 0) && (target[key] = source[key]);
+  return target;
 }
+var LinearGradientFrame = styled(YStack, {
+  name: "LinearGradient",
+  overflow: "hidden",
+  position: "relative"
+}), LinearGradient = LinearGradientFrame.styleable(function(propsIn, ref) {
+  var _props_colors, props = useProps(propsIn), start = props.start, end = props.end, colorsProp = props.colors, locations = props.locations, children = props.children, stackProps = _object_without_properties(props, [
+    "start",
+    "end",
+    "colors",
+    "locations",
+    "children"
+  ]), theme = useTheme(), colors = ((_props_colors = props.colors) === null || _props_colors === void 0 ? void 0 : _props_colors.map(function(c) {
+    var _theme_c, _theme_c_get;
+    return (_theme_c_get = (_theme_c = theme[c]) === null || _theme_c === void 0 ? void 0 : _theme_c.get("web")) !== null && _theme_c_get !== void 0 ? _theme_c_get : c;
+  })) || [];
+  return process.env.NODE_ENV !== "production" && colors.some(function(c) {
+    var normalized = normalizeColor(c);
+    if (!normalized || normalized.startsWith("$"))
+      return !0;
+  }) && (console.error('LinearGradient: "colors" prop contains invalid color tokens: '.concat(colors, ' fallback to default colors: ["#000", "#fff"]')), colors = [
+    "#000",
+    "#fff"
+  ]), /* @__PURE__ */ _jsxs(LinearGradientFrame, _object_spread_props(_object_spread({
+    ref
+  }, stackProps), {
+    children: [
+      /* @__PURE__ */ _jsx(ExpoLinearGradient, {
+        start,
+        end,
+        colors,
+        locations,
+        style: gradientStyle
+      }),
+      children
+    ]
+  }));
+}), gradientStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0
+};
 export {
   LinearGradient
 };
-//# sourceMappingURL=LinearGradient.native.js.map
+//# sourceMappingURL=LinearGradient.js.map

package/dist/jsx/LinearGradient.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/Users/n8/tamagui/code/ui/linear-gradient/src/LinearGradient.native.tsx"],
-  "mappings": ";AAGC,SAAA,iBAAA,KAAA,KAAA,OAAA;;;;;;;;;;;;;;;;;;;AAEM,SAASA,eAAeC,OAAK;AAClC,MAAMC,OAAOC,QAAQ,yBAAA,EAA2BH;AAChD,SAAO,qBAACE,MAAAA,eAAAA,CAAAA,GAASD,KAAAA,CAAAA;AACnB;",
-  "names": ["LinearGradient", "props", "Real", "require"]
+  "sources": ["../../src/Users/n8/tamagui/code/ui/linear-gradient/src/LinearGradient.tsx"],
+  "mappings": ";AACA,SAASA,gBAAgBC,QAAQC,UAAUC,gBAAgB;AAC3D,SAASC,cAAc;AAIvB,SAASC,kBAAkBC,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUrD,IAAMC,sBAAsBN,OAAOG,QAAQ;EACzCI,MAAM;EACNC,UAAU;EACVC,UAAU;AACZ,CAAA,GAEaL,iBAAiBE,oBAAoBI,UAChD,SAACC,SAASC,KAAAA;MAONC,eANIA,QAAQZ,SAASU,OAAAA,GAEfG,QAAuED,MAAvEC,OAAOC,MAAgEF,MAAhEE,KAAaC,aAAmDH,MAA3DI,QAAoBC,YAAuCL,MAAvCK,WAAWC,WAA4BN,MAA5BM,UAAaC,aAAAA,2BAAeP,OAAAA;IAAvEC;IAAOC;IAAKE;IAAoBC;IAAWC;MAC7CE,QAAQnB,SAAAA,GAEVe,WACFJ,gBAAAA,MAAMI,YAAM,QAAZJ,kBAAAA,SAAAA,SAAAA,cAAcS,IAAI,SAACC,GAAAA;QACTF,UAAAA;AAAR,YAAQA,gBAAAA,WAAAA,MAAME,CAAAA,OAAE,QAARF,aAAAA,SAAAA,SAAAA,SAAUG,IAAI,KAAA,OAAA,QAAdH,iBAAAA,SAAAA,eAAmCE;EAC7C,CAAA,MAAM,CAAA;AAER,SAAIE,QAAQC,IAAIC,aAAa,gBAEzBV,OAAOW,KAAK,SAACL,GAAAA;AACX,QAAMM,aAAa9B,eAAewB,CAAAA;AAClC,QAAI,CAACM,cAAcA,WAAWC,WAAW,GAAA;AACvC,aAAO;EAEX,CAAA,MAEAC,QAAQC,MACL,gEAAsE,OAAPf,QAAO,+CAAA,CAAA,GAEzEA,SAAS;IAAC;IAAQ;MAKpB,sBAACX,qBAAAA,qBAAAA,eAAAA;IAAoBM;KAAqBQ,UAAAA,GAAAA;;MACxC,qBAACf,oBAAAA;QACCS;QACAC;QACAE;QACAC;QACAe,OAAOC;;MAERf;;;AAGP,CAAA,GAKIe,gBAA2B;EAC/BzB,UAAU;EACV0B,KAAK;EACLC,MAAM;EACNC,OAAO;EACPC,QAAQ;EACRC,QAAQ;AACV;",
+  "names": ["normalizeColor", "styled", "useProps", "useTheme", "YStack", "LinearGradient", "ExpoLinearGradient", "LinearGradientFrame", "name", "overflow", "position", "styleable", "propsIn", "ref", "props", "start", "end", "colorsProp", "colors", "locations", "children", "stackProps", "theme", "map", "c", "get", "process", "env", "NODE_ENV", "some", "normalized", "startsWith", "console", "error", "style", "gradientStyle", "top", "left", "right", "bottom", "zIndex"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/linear-gradient",
-  "version": "1.108.4",
+  "version": "1.109.1",
   "sideEffects": [
     "*.css"
   ],
@@ -33,11 +33,11 @@
     }
   },
   "dependencies": {
-    "@tamagui/core": "1.108.4",
-    "@tamagui/stacks": "1.108.4"
+    "@tamagui/core": "1.109.1",
+    "@tamagui/stacks": "1.109.1"
   },
   "devDependencies": {
-    "@tamagui/build": "1.108.4",
+    "@tamagui/build": "1.109.1",
     "expo-linear-gradient": "~13.0.2",
     "react": "^18.2.0 || ^19.0.0"
   },

package/src/LinearGradient.tsx

@@ -1 +1,75 @@
-export * from './LinearGradient-shared'
+import type { ColorTokens, GetProps, ThemeTokens } from '@tamagui/core'
+import { normalizeColor, styled, useProps, useTheme } from '@tamagui/core'
+import { YStack } from '@tamagui/stacks'
+import type { ViewStyle } from 'react-native'
+
+import type { LinearGradientPoint } from './linear-gradient'
+import { LinearGradient as ExpoLinearGradient } from './linear-gradient'
+
+// taken from expo-linear-gradient
+export type LinearGradientExtraProps = {
+  colors?: (ColorTokens | ThemeTokens | (string & {}))[]
+  locations?: number[] | null
+  start?: LinearGradientPoint | null
+  end?: LinearGradientPoint | null
+}
+
+const LinearGradientFrame = styled(YStack, {
+  name: 'LinearGradient',
+  overflow: 'hidden',
+  position: 'relative',
+})
+
+export const LinearGradient = LinearGradientFrame.styleable<LinearGradientExtraProps>(
+  (propsIn, ref) => {
+    const props = useProps(propsIn)
+
+    const { start, end, colors: colorsProp, locations, children, ...stackProps } = props
+    const theme = useTheme()
+
+    let colors =
+      props.colors?.map((c) => {
+        return (theme[c]?.get('web') as string) ?? c
+      }) || []
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (
+        colors.some((c) => {
+          const normalized = normalizeColor(c)
+          if (!normalized || normalized.startsWith('$')) {
+            return true
+          }
+        })
+      ) {
+        console.error(
+          `LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`
+        )
+        colors = ['#000', '#fff']
+      }
+    }
+
+    return (
+      <LinearGradientFrame ref={ref as any} {...stackProps}>
+        <ExpoLinearGradient
+          start={start}
+          end={end}
+          colors={colors}
+          locations={locations}
+          style={gradientStyle}
+        />
+        {children}
+      </LinearGradientFrame>
+    )
+  }
+)
+
+export type LinearGradientProps = GetProps<typeof LinearGradient>
+
+const gradientStyle: ViewStyle = {
+  position: 'absolute',
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  zIndex: 0,
+}

package/types/LinearGradient.d.ts

@@ -1,2 +1,29 @@
-export * from './LinearGradient-shared';
+import type { ColorTokens, GetProps, ThemeTokens } from '@tamagui/core';
+import type { LinearGradientPoint } from './linear-gradient';
+export type LinearGradientExtraProps = {
+    colors?: (ColorTokens | ThemeTokens | (string & {}))[];
+    locations?: number[] | null;
+    start?: LinearGradientPoint | null;
+    end?: LinearGradientPoint | null;
+};
+export declare const LinearGradient: import("@tamagui/core").TamaguiComponent<Omit<import("@tamagui/core").GetFinalProps<import("@tamagui/core").RNTamaguiViewNonStyleProps, import("@tamagui/core").StackStyleBase, {
+    elevation?: number | import("@tamagui/core").SizeTokens | undefined;
+    fullscreen?: boolean | undefined;
+    inset?: number | import("@tamagui/core").SizeTokens | {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    } | undefined;
+}>, keyof LinearGradientExtraProps> & LinearGradientExtraProps, import("@tamagui/core").TamaguiElement, import("@tamagui/core").RNTamaguiViewNonStyleProps & LinearGradientExtraProps, import("@tamagui/core").StackStyleBase, {
+    elevation?: number | import("@tamagui/core").SizeTokens | undefined;
+    fullscreen?: boolean | undefined;
+    inset?: number | import("@tamagui/core").SizeTokens | {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    } | undefined;
+}, import("@tamagui/core").StaticConfigPublic>;
+export type LinearGradientProps = GetProps<typeof LinearGradient>;
 //# sourceMappingURL=LinearGradient.d.ts.map

package/types/LinearGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LinearGradient.d.ts","sourceRoot":"","sources":["../src/LinearGradient.tsx"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA"}
+{"version":3,"file":"LinearGradient.d.ts","sourceRoot":"","sources":["../src/LinearGradient.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAKvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAI5D,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,CAAC,EAAE,CAAC,WAAW,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAA;IACtD,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;IAC3B,KAAK,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAClC,GAAG,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;CACjC,CAAA;AAQD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;8CAyC1B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/src/LinearGradient-shared.tsx

@@ -1,75 +0,0 @@
-import type { ColorTokens, GetProps, ThemeTokens } from '@tamagui/core'
-import { normalizeColor, styled, useProps, useTheme } from '@tamagui/core'
-import { YStack } from '@tamagui/stacks'
-import type { ViewStyle } from 'react-native'
-
-import type { LinearGradientPoint } from './linear-gradient'
-import { LinearGradient as ExpoLinearGradient } from './linear-gradient'
-
-// taken from expo-linear-gradient
-export type LinearGradientExtraProps = {
-  colors?: (ColorTokens | ThemeTokens | (string & {}))[]
-  locations?: number[] | null
-  start?: LinearGradientPoint | null
-  end?: LinearGradientPoint | null
-}
-
-const LinearGradientFrame = styled(YStack, {
-  name: 'LinearGradient',
-  overflow: 'hidden',
-  position: 'relative',
-})
-
-export const LinearGradient = LinearGradientFrame.styleable<LinearGradientExtraProps>(
-  (propsIn, ref) => {
-    const props = useProps(propsIn)
-
-    const { start, end, colors: colorsProp, locations, children, ...stackProps } = props
-    const theme = useTheme()
-
-    let colors =
-      props.colors?.map((c) => {
-        return (theme[c]?.get('web') as string) ?? c
-      }) || []
-
-    if (process.env.NODE_ENV !== 'production') {
-      if (
-        colors.some((c) => {
-          const normalized = normalizeColor(c)
-          if (!normalized || normalized.startsWith('$')) {
-            return true
-          }
-        })
-      ) {
-        console.error(
-          `LinearGradient: "colors" prop contains invalid color tokens: ${colors} fallback to default colors: ["#000", "#fff"]`
-        )
-        colors = ['#000', '#fff']
-      }
-    }
-
-    return (
-      <LinearGradientFrame ref={ref as any} {...stackProps}>
-        <ExpoLinearGradient
-          start={start}
-          end={end}
-          colors={colors}
-          locations={locations}
-          style={gradientStyle}
-        />
-        {children}
-      </LinearGradientFrame>
-    )
-  }
-)
-
-export type LinearGradientProps = GetProps<typeof LinearGradient>
-
-const gradientStyle: ViewStyle = {
-  position: 'absolute',
-  top: 0,
-  left: 0,
-  right: 0,
-  bottom: 0,
-  zIndex: 0,
-}

package/src/LinearGradient.native.tsx

@@ -1,9 +0,0 @@
-/**
- * Fake file require just so native users can avoid installing
- * expo stuff up front for native.
- */
-
-export function LinearGradient(props) {
-  const Real = require('./LinearGradient-shared').LinearGradient
-  return <Real {...props} />
-}