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

package/dist/cjs/modules/useLocale/isLocaleRTL.cjs

@@ -0,0 +1,88 @@
+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 isLocaleRTL_exports = {};
+__export(isLocaleRTL_exports, {
+  isLocaleRTL: () => isLocaleRTL
+});
+module.exports = __toCommonJS(isLocaleRTL_exports);
+const rtlScripts = /* @__PURE__ */new Set(["Arab", "Syrc", "Samr", "Mand", "Thaa", "Mend", "Nkoo", "Adlm", "Rohg", "Hebr"]);
+const rtlLangs = /* @__PURE__ */new Set(["ae",
+// Avestan
+"ar",
+// Arabic
+"arc",
+// Aramaic
+"bcc",
+// Southern Balochi
+"bqi",
+// Bakthiari
+"ckb",
+// Sorani
+"dv",
+// Dhivehi
+"fa", "far",
+// Persian
+"glk",
+// Gilaki
+"he", "iw",
+// Hebrew
+"khw",
+// Khowar
+"ks",
+// Kashmiri
+"ku",
+// Kurdish
+"mzn",
+// Mazanderani
+"nqo",
+// N'Ko
+"pnb",
+// Western Punjabi
+"ps",
+// Pashto
+"sd",
+// Sindhi
+"ug",
+// Uyghur
+"ur",
+// Urdu
+"yi"
+// Yiddish
+]);
+const cache = /* @__PURE__ */new Map();
+function isLocaleRTL(locale) {
+  const cachedRTL = cache.get(locale);
+  if (cachedRTL) {
+    return cachedRTL;
+  }
+  let isRTL = false;
+  if (Intl.Locale) {
+    const script = new Intl.Locale(locale).maximize().script;
+    isRTL = rtlScripts.has(script);
+  } else {
+    const lang = locale.split("-")[0];
+    isRTL = rtlLangs.has(lang);
+  }
+  cache.set(locale, isRTL);
+  return isRTL;
+}

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

@@ -0,0 +1,125 @@
+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_react = require("@testing-library/react");
+var React = __toESM(require("react"), 1);
+var import_test_utils = require("react-dom/test-utils");
+var import__ = __toESM(require("../index.cjs"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+describe("modules/useMergeRefs/index.js", () => {
+  function TestComponent({
+    refs,
+    ...rest
+  }) {
+    const mergedRef = (0, import__.default)(...refs);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)("div", {
+      ref: mergedRef,
+      ...rest
+    });
+  }
+  afterEach(import_react.cleanup);
+  test("handles no refs", () => {
+    (0, import_test_utils.act)(() => {
+      (0, import_react.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        refs: []
+      }));
+    });
+  });
+  test("merges any number of varying refs", () => {
+    const callbackRef1 = jest.fn();
+    const callbackRef2 = jest.fn();
+    const objectRef1 = React.createRef();
+    const objectRef2 = React.createRef();
+    const nullRef = null;
+    (0, import_test_utils.act)(() => {
+      (0, import_react.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        refs: [callbackRef1, callbackRef2, objectRef1, objectRef2, nullRef]
+      }));
+    });
+    expect(callbackRef1).toHaveBeenCalledTimes(1);
+    expect(callbackRef2).toHaveBeenCalledTimes(1);
+    expect(objectRef1.current).toBeInstanceOf(HTMLDivElement);
+    expect(objectRef2.current).toBeInstanceOf(HTMLDivElement);
+  });
+  test("ref is called when ref changes", () => {
+    const ref = jest.fn();
+    const nextRef = jest.fn();
+    let rerender;
+    (0, import_test_utils.act)(() => {
+      ;
+      ({
+        rerender
+      } = (0, import_react.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        refs: [ref]
+      })));
+    });
+    expect(ref).toHaveBeenCalled();
+    (0, import_test_utils.act)(() => {
+      rerender(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        refs: [nextRef]
+      }));
+    });
+    expect(nextRef).toHaveBeenCalled();
+  });
+  test("ref is not called for each rerender", () => {
+    const ref = jest.fn();
+    let rerender;
+    (0, import_test_utils.act)(() => {
+      ;
+      ({
+        rerender
+      } = (0, import_react.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        refs: [ref]
+      })));
+    });
+    expect(ref).toHaveBeenCalledTimes(1);
+    (0, import_test_utils.act)(() => {
+      rerender(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        refs: [ref]
+      }));
+    });
+    expect(ref).toHaveBeenCalledTimes(1);
+  });
+  test("ref is not called for props changes", () => {
+    const ref = jest.fn();
+    let rerender;
+    (0, import_test_utils.act)(() => {
+      ;
+      ({
+        rerender
+      } = (0, import_react.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        id: "foo",
+        refs: [ref]
+      })));
+    });
+    expect(ref).toHaveBeenCalledTimes(1);
+    (0, import_test_utils.act)(() => {
+      rerender(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        id: "bar",
+        refs: [ref]
+      }));
+    });
+    expect(ref).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/cjs/modules/useMergeRefs/index.cjs

@@ -0,0 +1,45 @@
+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 useMergeRefs_exports = {};
+__export(useMergeRefs_exports, {
+  useMergeRefs: () => useMergeRefs
+});
+module.exports = __toCommonJS(useMergeRefs_exports);
+var React = __toESM(require("react"), 1);
+var import_mergeRefs = require("../mergeRefs/index.cjs");
+function useMergeRefs(...args) {
+  return React.useMemo(() => (0, import_mergeRefs.mergeRefs)(...args),
+  // eslint-disable-next-line
+  [...args]);
+}

package/dist/cjs/modules/usePlatformMethods/index.cjs

@@ -0,0 +1,42 @@
+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 usePlatformMethods_exports = {};
+__export(usePlatformMethods_exports, {
+  usePlatformMethods: () => usePlatformMethods
+});
+module.exports = __toCommonJS(usePlatformMethods_exports);
+var import_use_element_layout = require("@hanzogui/use-element-layout");
+var import_useStable = require("../useStable/index.cjs");
+function usePlatformMethods({
+  pointerEvents,
+  style
+}) {
+  const ref = (0, import_useStable.useStable)(() => hostNode => {
+    if (hostNode != null) {
+      hostNode.measure = (0, import_use_element_layout.createMeasure)(hostNode);
+      hostNode.measureLayout = (0, import_use_element_layout.createMeasureLayout)(hostNode);
+      hostNode.measureInWindow = (0, import_use_element_layout.createMeasureInWindow)(hostNode);
+    }
+  });
+  return ref;
+}

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

@@ -0,0 +1,122 @@
+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 ReactDOM = __toESM(require("react-dom"), 1);
+var import_test_utils = require("react-dom/test-utils");
+var import__ = __toESM(require("../index.cjs"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+function createRoot(rootNode) {
+  return {
+    render(element) {
+      ReactDOM.render(element, rootNode);
+    }
+  };
+}
+describe("useStable", () => {
+  let root;
+  let rootNode;
+  let spy = {};
+  const TestComponent = ({
+    initialValueCallback
+  }) => {
+    const value = (0, import__.default)(initialValueCallback);
+    spy.value = value;
+    return null;
+  };
+  beforeEach(() => {
+    spy = {};
+    rootNode = document.createElement("div");
+    document.body.appendChild(rootNode);
+    root = createRoot(rootNode);
+  });
+  afterEach(() => {
+    root.render(null);
+    document.body.removeChild(rootNode);
+    rootNode = null;
+    root = null;
+  });
+  test("correctly sets the initial value", () => {
+    const initialValueCallback = () => 5;
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(spy.value).toBe(5);
+  });
+  test("does not change the value", () => {
+    let counter = 0;
+    const initialValueCallback = () => counter++;
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(spy.value).toBe(0);
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(spy.value).toBe(0);
+  });
+  test("only calls the callback once", () => {
+    let counter = 0;
+    const initialValueCallback = () => counter++;
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(counter).toBe(1);
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(counter).toBe(1);
+  });
+  test("does not change the value if the callback initially returns null", () => {
+    let counter = 0;
+    const initialValueCallback = () => {
+      if (counter === 0) {
+        counter++;
+        return null;
+      }
+      return counter++;
+    };
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(spy.value).toBe(null);
+    (0, import_test_utils.act)(() => {
+      root.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(TestComponent, {
+        initialValueCallback
+      }));
+    });
+    expect(spy.value).toBe(null);
+  });
+});

package/dist/cjs/modules/useStable/index.cjs

@@ -0,0 +1,47 @@
+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 useStable_exports = {};
+__export(useStable_exports, {
+  useStable: () => useStable
+});
+module.exports = __toCommonJS(useStable_exports);
+var React = __toESM(require("react"), 1);
+const UNINITIALIZED = typeof Symbol === "function" && typeof /* @__PURE__ */Symbol() === "symbol" ? /* @__PURE__ */Symbol() : Object.freeze({});
+function useStable(getInitialValue) {
+  const ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = getInitialValue();
+  }
+  return ref.current;
+}

package/dist/cjs/styleTypes.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var styleTypes_exports = {};
+module.exports = __toCommonJS(styleTypes_exports);

package/dist/cjs/types.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);