@hanzogui/react-native-web-internals 2.0.0-rc.41-hanzoai.5

package/dist/cjs/modules/processColor/__tests__/index-test.cjs

@@ -0,0 +1,85 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var import__ = __toESM(require("../index.cjs"), 1);
+const platformSpecific = x => x;
+describe("processColor", () => {
+  describe("predefined color names", () => {
+    it("should convert red", () => {
+      const colorFromString = (0, import__.default)("red");
+      const expectedInt = 4294901760;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+    it("should convert white", () => {
+      const colorFromString = (0, import__.default)("white");
+      const expectedInt = 4294967295;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+    it("should convert black", () => {
+      const colorFromString = (0, import__.default)("black");
+      const expectedInt = 4278190080;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+    it("should convert transparent", () => {
+      const colorFromString = (0, import__.default)("transparent");
+      const expectedInt = 0;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+  });
+  describe("RGB strings", () => {
+    it("should convert rgb(x, y, z)", () => {
+      const colorFromString = (0, import__.default)("rgb(10, 20, 30)");
+      const expectedInt = 4278850590;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+  });
+  describe("RGBA strings", () => {
+    it("should convert rgba(x, y, z, a)", () => {
+      const colorFromString = (0, import__.default)("rgba(10, 20, 30, 0.4)");
+      const expectedInt = 1711936542;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+  });
+  describe("HSL strings", () => {
+    it("should convert hsl(x, y%, z%)", () => {
+      const colorFromString = (0, import__.default)("hsl(318, 69%, 55%)");
+      const expectedInt = 4292558252;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+  });
+  describe("HSLA strings", () => {
+    it("should convert hsla(x, y%, z%, a)", () => {
+      const colorFromString = (0, import__.default)("hsla(318, 69%, 55%, 0.25)");
+      const expectedInt = 1088109996;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+  });
+  describe("hex strings", () => {
+    it("should convert #xxxxxx", () => {
+      const colorFromString = (0, import__.default)("#1e83c9");
+      const expectedInt = 4280189897;
+      expect(colorFromString).toEqual(platformSpecific(expectedInt));
+    });
+  });
+});

package/dist/cjs/modules/processColor/index.cjs

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var processColor_exports = {};
+__export(processColor_exports, {
+  processColor: () => processColor
+});
+module.exports = __toCommonJS(processColor_exports);
+var import_normalize_css_color = __toESM(require("@hanzogui/normalize-css-color"), 1);
+const processColor = color => {
+  if (color === void 0 || color === null) {
+    return color;
+  }
+  let int32Color = (0, import_normalize_css_color.default)(color);
+  if (int32Color === void 0 || int32Color === null) {
+    return void 0;
+  }
+  int32Color = (int32Color << 24 | int32Color >>> 8) >>> 0;
+  return int32Color;
+};

package/dist/cjs/modules/requestIdleCallback/index.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var requestIdleCallback_exports = {};
+__export(requestIdleCallback_exports, {
+  cancelIdleCallback: () => cancelIdleCallback,
+  requestIdleCallback: () => requestIdleCallback
+});
+module.exports = __toCommonJS(requestIdleCallback_exports);
+var import_canUseDOM = require("../canUseDOM.cjs");
+const _requestIdleCallback = function (cb, options) {
+  return setTimeout(() => {
+    const start = Date.now();
+    cb({
+      didTimeout: false,
+      timeRemaining() {
+        return Math.max(0, 50 - (Date.now() - start));
+      }
+    });
+  }, 1);
+};
+const _cancelIdleCallback = function (id) {
+  clearTimeout(id);
+};
+const isSupported = import_canUseDOM.canUseDOM && typeof window.requestIdleCallback !== "undefined";
+const requestIdleCallback = isSupported ? window.requestIdleCallback : _requestIdleCallback;
+const cancelIdleCallback = isSupported ? window.cancelIdleCallback : _cancelIdleCallback;

package/dist/cjs/modules/setValueForStyles/dangerousStyleValue.cjs

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var dangerousStyleValue_exports = {};
+__export(dangerousStyleValue_exports, {
+  dangerousStyleValue: () => dangerousStyleValue
+});
+module.exports = __toCommonJS(dangerousStyleValue_exports);
+var import_unitlessNumbers = require("../unitlessNumbers/index.cjs");
+var import_normalizeValueWithProperty = require("../../StyleSheet/compiler/normalizeValueWithProperty.cjs");
+function dangerousStyleValue(name, value, isCustomProperty) {
+  var isEmpty = value == null || typeof value === "boolean" || value === "";
+  if (isEmpty) {
+    return "";
+  }
+  if (typeof value === "object" && typeof value.__getValue === "function") {
+    value = value.__getValue();
+  }
+  if (name === "transform" && Array.isArray(value)) {
+    return value.map(t => {
+      const key = Object.keys(t)[0];
+      let val = t[key];
+      if (typeof val === "object" && typeof val.__getValue === "function") {
+        val = val.__getValue();
+      }
+      if (key === "matrix" || key === "matrix3d") {
+        return `${key}(${val.join(",")})`;
+      }
+      return `${key}(${(0, import_normalizeValueWithProperty.normalizeValueWithProperty)(val, key)})`;
+    }).join(" ");
+  }
+  if (!isCustomProperty && typeof value === "number" && value !== 0 && !(import_unitlessNumbers.unitlessNumbers.hasOwnProperty(name) && import_unitlessNumbers.unitlessNumbers[name])) {
+    return value + "px";
+  }
+  return ("" + value).trim();
+}

package/dist/cjs/modules/setValueForStyles/index.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var setValueForStyles_exports = {};
+__export(setValueForStyles_exports, {
+  setValueForStyles: () => setValueForStyles
+});
+module.exports = __toCommonJS(setValueForStyles_exports);
+var import_dangerousStyleValue = require("./dangerousStyleValue.cjs");
+function setValueForStyles(node, styles) {
+  const style = node.style;
+  for (let styleName in styles) {
+    if (!styles.hasOwnProperty(styleName)) {
+      continue;
+    }
+    const isCustomProperty = styleName.indexOf("--") === 0;
+    const styleValue = (0, import_dangerousStyleValue.dangerousStyleValue)(styleName, styles[styleName], isCustomProperty);
+    if (styleName === "float") {
+      styleName = "cssFloat";
+    }
+    if (isCustomProperty) {
+      style.setProperty(styleName, styleValue);
+    } else {
+      style[styleName] = styleValue;
+    }
+  }
+}

package/dist/cjs/modules/unitlessNumbers/index.cjs

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var unitlessNumbers_exports = {};
+__export(unitlessNumbers_exports, {
+  unitlessNumbers: () => unitlessNumbers
+});
+module.exports = __toCommonJS(unitlessNumbers_exports);
+const unitlessNumbers = {
+  animationIterationCount: true,
+  aspectRatio: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  flex: true,
+  flexGrow: true,
+  flexOrder: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  fontWeight: true,
+  gap: true,
+  columnGap: true,
+  rowGap: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowGap: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnGap: true,
+  gridColumnStart: true,
+  lineClamp: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true,
+  // transform types
+  scale: true,
+  scaleX: true,
+  scaleY: true,
+  scaleZ: true,
+  // RN properties
+  shadowOpacity: true
+};
+const prefixes = ["ms", "Moz", "O", "Webkit"];
+const prefixKey = (prefix, key) => {
+  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
+};
+Object.keys(unitlessNumbers).forEach(prop => {
+  prefixes.forEach(prefix => {
+    unitlessNumbers[prefixKey(prefix, prop)] = unitlessNumbers[prop];
+  });
+});

package/dist/cjs/modules/useElementLayout/index.cjs

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useElementLayout_exports = {};
+__export(useElementLayout_exports, {
+  useElementLayout: () => useElementLayout
+});
+module.exports = __toCommonJS(useElementLayout_exports);
+var import_use_element_layout = require("@hanzogui/use-element-layout");
+var import_react = require("react");
+function useElementLayout(ref, onLayout) {
+  const wrappedRef = (0, import_react.useMemo)(() => {
+    return {
+      current: {
+        get host() {
+          return ref.current;
+        }
+      }
+    };
+  }, [ref]);
+  (0, import_react.useEffect)(() => {
+    (0, import_use_element_layout.enable)();
+  }, []);
+  return (0, import_use_element_layout.useElementLayout)(wrappedRef, onLayout);
+}