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

package/dist/cjs/modules/InteractionManager.cjs

@@ -0,0 +1,240 @@
+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 InteractionManager_exports = {};
+__export(InteractionManager_exports, {
+  InteractionManager: () => InteractionManager
+});
+module.exports = __toCommonJS(InteractionManager_exports);
+var import_invariant = require("./invariant.cjs");
+var import_requestIdleCallback = require("./requestIdleCallback/index.cjs");
+class EventEmitter {
+  _registry = {};
+  addListener(eventType, listener, context) {
+    const registrations = this._allocate(eventType);
+    const registration = {
+      context,
+      listener,
+      remove: () => {
+        registrations.delete(registration);
+      }
+    };
+    registrations.add(registration);
+    return registration;
+  }
+  emit(eventType, ...args) {
+    const registrations = this._registry[eventType];
+    if (registrations != null) {
+      for (const registration of Array.from(registrations)) {
+        registration.listener.apply(registration.context, args);
+      }
+    }
+  }
+  _allocate(eventType) {
+    let registrations = this._registry[eventType];
+    if (registrations == null) {
+      registrations = /* @__PURE__ */new Set();
+      this._registry[eventType] = registrations;
+    }
+    return registrations;
+  }
+}
+class TaskQueue {
+  _queueStack;
+  _onMoreTasks;
+  constructor({
+    onMoreTasks
+  }) {
+    this._onMoreTasks = onMoreTasks;
+    this._queueStack = [{
+      tasks: [],
+      popable: true
+    }];
+  }
+  enqueueTasks(tasks) {
+    tasks.forEach(task => this._enqueue(task));
+  }
+  cancelTasks(tasksToCancel) {
+    this._queueStack = this._queueStack.map(queue => ({
+      ...queue,
+      tasks: queue.tasks.filter(task => !tasksToCancel.includes(task))
+    })).filter((queue, idx) => queue.tasks.length > 0 || idx === 0);
+  }
+  hasTasksToProcess() {
+    return this._getCurrentQueue().length > 0;
+  }
+  processNext() {
+    const queue = this._getCurrentQueue();
+    if (queue.length) {
+      const task = queue.shift();
+      try {
+        if (typeof task === "object" && task && "gen" in task) {
+          this._genPromise(task);
+        } else if (typeof task === "object" && task && "run" in task) {
+          ;
+          task.run();
+        } else {
+          (0, import_invariant.invariant)(typeof task === "function", "Expected Function, SimpleTask, or PromiseTask, but got:\n" + JSON.stringify(task, null, 2));
+          task();
+        }
+      } catch (e) {
+        if (e instanceof Error) {
+          const taskName = task && typeof task === "object" && "name" in task ? task.name : "";
+          e.message = "TaskQueue: Error with task " + taskName + ": " + e.message;
+        }
+        throw e;
+      }
+    }
+  }
+  _enqueue(task) {
+    this._getCurrentQueue().push(task);
+  }
+  _getCurrentQueue() {
+    const stackIdx = this._queueStack.length - 1;
+    const queue = this._queueStack[stackIdx];
+    if (queue.popable && queue.tasks.length === 0 && stackIdx > 0) {
+      this._queueStack.pop();
+      return this._getCurrentQueue();
+    } else {
+      return queue.tasks;
+    }
+  }
+  _genPromise(task) {
+    const length = this._queueStack.push({
+      tasks: [],
+      popable: false
+    });
+    const stackIdx = length - 1;
+    const stackItem = this._queueStack[stackIdx];
+    task.gen().then(() => {
+      stackItem.popable = true;
+      if (this.hasTasksToProcess()) {
+        this._onMoreTasks();
+      }
+    }).catch(ex => {
+      setTimeout(() => {
+        if (ex instanceof Error) {
+          ex.message = `TaskQueue: Error resolving Promise in task ${task.name}: ${ex.message}`;
+        }
+        throw ex;
+      }, 0);
+    });
+  }
+}
+const _emitter = new EventEmitter();
+const InteractionManager = {
+  Events: {
+    interactionStart: "interactionStart",
+    interactionComplete: "interactionComplete"
+  },
+  /**
+   * Schedule a function to run after all interactions have completed.
+   */
+  runAfterInteractions(task) {
+    const tasks = [];
+    const promise = new Promise(resolve => {
+      _scheduleUpdate();
+      if (task) {
+        tasks.push(task);
+      }
+      tasks.push({
+        run: resolve,
+        name: "resolve " + (task && typeof task === "object" && "name" in task && task.name || "?")
+      });
+      _taskQueue.enqueueTasks(tasks);
+    });
+    return {
+      then: promise.then.bind(promise),
+      done: promise.then.bind(promise),
+      cancel: () => {
+        _taskQueue.cancelTasks(tasks);
+      }
+    };
+  },
+  /**
+   * Notify manager that an interaction has started.
+   */
+  createInteractionHandle() {
+    _scheduleUpdate();
+    const handle = ++_inc;
+    _addInteractionSet.add(handle);
+    return handle;
+  },
+  /**
+   * Notify manager that an interaction has completed.
+   */
+  clearInteractionHandle(handle) {
+    (0, import_invariant.invariant)(!!handle, "Must provide a handle to clear.");
+    _scheduleUpdate();
+    _addInteractionSet.delete(handle);
+    _deleteInteractionSet.add(handle);
+  },
+  addListener: _emitter.addListener.bind(_emitter),
+  /**
+   * Set deadline for task processing
+   */
+  setDeadline(deadline) {
+    _deadline = deadline;
+  }
+};
+const _interactionSet = /* @__PURE__ */new Set();
+const _addInteractionSet = /* @__PURE__ */new Set();
+const _deleteInteractionSet = /* @__PURE__ */new Set();
+const _taskQueue = new TaskQueue({
+  onMoreTasks: _scheduleUpdate
+});
+let _nextUpdateHandle = null;
+let _inc = 0;
+let _deadline = -1;
+function _scheduleUpdate() {
+  if (!_nextUpdateHandle) {
+    if (_deadline > 0) {
+      _nextUpdateHandle = setTimeout(_processUpdate);
+    } else {
+      _nextUpdateHandle = (0, import_requestIdleCallback.requestIdleCallback)(_processUpdate);
+    }
+  }
+}
+function _processUpdate() {
+  _nextUpdateHandle = null;
+  const interactionCount = _interactionSet.size;
+  _addInteractionSet.forEach(handle => _interactionSet.add(handle));
+  _deleteInteractionSet.forEach(handle => _interactionSet.delete(handle));
+  const nextInteractionCount = _interactionSet.size;
+  if (interactionCount !== 0 && nextInteractionCount === 0) {
+    _emitter.emit("interactionComplete");
+  } else if (interactionCount === 0 && nextInteractionCount !== 0) {
+    _emitter.emit("interactionStart");
+  }
+  if (nextInteractionCount === 0) {
+    const begin = Date.now();
+    while (_taskQueue.hasTasksToProcess()) {
+      _taskQueue.processNext();
+      if (_deadline > 0 && Date.now() - begin >= _deadline) {
+        _scheduleUpdate();
+        break;
+      }
+    }
+  }
+  _addInteractionSet.clear();
+  _deleteInteractionSet.clear();
+}

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

@@ -0,0 +1,56 @@
+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);
+describe("apis/Platform", () => {
+  describe("select", () => {
+    test('supports "default"', () => {
+      expect(import__.default.select({
+        default: "default"
+      })).toEqual("default");
+    });
+    test('chooses "web"', () => {
+      expect(import__.default.select({
+        android: "android",
+        ios: "ios",
+        web: "web",
+        default: "default"
+      })).toEqual("web");
+    });
+  });
+  describe("isTesting", () => {
+    const NODE_ENV_BACKUP = process.env.NODE_ENV;
+    afterEach(() => {
+      process.env.NODE_ENV = NODE_ENV_BACKUP;
+    });
+    test('true when NODE_ENV is "test"', () => {
+      process.env.NODE_ENV = "test";
+      expect(import__.default.isTesting).toEqual(true);
+    });
+    test('false when NODE_ENV is not "test"', () => {
+      process.env.NODE_ENV = "development";
+      expect(import__.default.isTesting).toEqual(false);
+    });
+  });
+});

package/dist/cjs/modules/Platform/index.cjs

@@ -0,0 +1,32 @@
+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 Platform_exports = {};
+__export(Platform_exports, {
+  Platform: () => Platform
+});
+module.exports = __toCommonJS(Platform_exports);
+const Platform = {
+  OS: "web",
+  select: obj => "web" in obj ? obj.web : obj.default,
+  isTesting: process.env.NODE_ENV === "test"
+};

package/dist/cjs/modules/TextInputState/index.cjs

@@ -0,0 +1,70 @@
+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 TextInputState_exports = {};
+__export(TextInputState_exports, {
+  TextInputState: () => TextInputState
+});
+module.exports = __toCommonJS(TextInputState_exports);
+var import_UIManager = require("../UIManager/index.cjs");
+const TextInputState = {
+  /**
+   * Internal state
+   */
+  _currentlyFocusedNode: null,
+  /**
+   * Returns the ID of the currently focused text field, if one exists
+   * If no text field is focused it returns null
+   */
+  currentlyFocusedField() {
+    if (document.activeElement !== this._currentlyFocusedNode) {
+      this._currentlyFocusedNode = null;
+    }
+    return this._currentlyFocusedNode;
+  },
+  /**
+   * @param {Object} TextInputID id of the text field to focus
+   * Focuses the specified text field
+   * noop if the text field was already focused
+   */
+  focusTextInput(textFieldNode) {
+    if (textFieldNode !== null) {
+      this._currentlyFocusedNode = textFieldNode;
+      if (document.activeElement !== textFieldNode) {
+        import_UIManager.UIManager.focus(textFieldNode);
+      }
+    }
+  },
+  /**
+   * @param {Object} textFieldNode id of the text field to focus
+   * Unfocuses the specified text field
+   * noop if it wasn't focused
+   */
+  blurTextInput(textFieldNode) {
+    if (textFieldNode !== null) {
+      this._currentlyFocusedNode = null;
+      if (document.activeElement === textFieldNode) {
+        import_UIManager.UIManager.blur(textFieldNode);
+      }
+    }
+  }
+};

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

@@ -0,0 +1,111 @@
+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 createStyledNode = (name = "div", style = {}) => {
+  const root = document.createElement(name);
+  Object.keys(style).forEach(prop => {
+    root.style[prop] = style[prop];
+  });
+  return root;
+};
+const componentStub = {
+  _reactInternalInstance: {
+    _currentElement: {
+      _owner: {}
+    },
+    _debugID: 1
+  }
+};
+describe("apis/UIManager", () => {
+  describe("focus", () => {
+    test('sets tabIndex="-1" on elements not programmatically focusable by default', () => {
+      const node = createStyledNode();
+      import__.default.focus(node);
+      expect(node.getAttribute("tabIndex")).toEqual("-1");
+    });
+    test(`doesn't set tabIndex="-1" on elements with an existing tabIndex`, () => {
+      const node = createStyledNode();
+      node.tabIndex = 0;
+      import__.default.focus(node);
+      expect(node.getAttribute("tabIndex")).toEqual("0");
+    });
+    test(`doesn't set tabIndex="-1" on elements focusable by default`, () => {
+      ;
+      ["a", "input", "select", "textarea"].forEach(name => {
+        const node = createStyledNode(name);
+        import__.default.focus(node);
+        expect(node.getAttribute("tabIndex")).toBeNull();
+      });
+    });
+  });
+  describe("updateView", () => {
+    test("supports className alias for class", () => {
+      const node = createStyledNode();
+      const props = {
+        className: "extra"
+      };
+      import__.default.updateView(node, props, componentStub);
+      expect(node.getAttribute("class")).toEqual("extra");
+    });
+    test("adds correct DOM styles to existing style", () => {
+      const node = createStyledNode("div", {
+        color: "red"
+      });
+      const props = {
+        style: {
+          marginTop: 0,
+          marginBottom: 0,
+          opacity: 0
+        }
+      };
+      import__.default.updateView(node, props, componentStub);
+      expect(node.getAttribute("style")).toEqual("color: red; margin-top: 0px; margin-bottom: 0px; opacity: 0;");
+    });
+    test("replaces input and textarea text", () => {
+      const node = createStyledNode("textarea");
+      node.value = "initial";
+      const textProp = {
+        text: "expected-text"
+      };
+      const valueProp = {
+        value: "expected-value"
+      };
+      import__.default.updateView(node, textProp);
+      expect(node.value).toEqual("expected-text");
+      import__.default.updateView(node, valueProp);
+      expect(node.value).toEqual("expected-value");
+    });
+    test("sets other attribute values", () => {
+      const node = createStyledNode();
+      const props = {
+        "aria-level": "4",
+        "data-of-type": "string"
+      };
+      import__.default.updateView(node, props);
+      expect(node.getAttribute("aria-level")).toEqual("4");
+      expect(node.getAttribute("data-of-type")).toEqual("string");
+    });
+  });
+});

package/dist/cjs/modules/UIManager/index.cjs

@@ -0,0 +1,65 @@
+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 UIManager_exports = {};
+__export(UIManager_exports, {
+  UIManager: () => UIManager
+});
+module.exports = __toCommonJS(UIManager_exports);
+var import_use_element_layout = require("@hanzogui/use-element-layout");
+const focusableElements = {
+  A: true,
+  INPUT: true,
+  SELECT: true,
+  TEXTAREA: true
+};
+const UIManager = {
+  blur(node) {
+    try {
+      node.blur();
+    } catch (err) {}
+  },
+  focus(node) {
+    try {
+      const name = node.nodeName;
+      if (node.getAttribute("tabIndex") == null && focusableElements[name] == null) {
+        node.setAttribute("tabIndex", "-1");
+      }
+      node.focus();
+    } catch (err) {}
+  },
+  measure(node, callback) {
+    return (0, import_use_element_layout.measure)(node, callback);
+  },
+  measureInWindow(node, callback) {
+    return (0, import_use_element_layout.measureInWindow)(node, callback);
+  },
+  // note its flipped fail and success on purpose lol
+  async measureLayout(node, relativeToNativeNode, onFail, onSuccess) {
+    return measureLayout(node, relativeToNativeNode, onSuccess);
+  },
+  configureNextLayoutAnimation(config, onAnimationDidEnd) {
+    onAnimationDidEnd();
+  },
+  // mocks
+  setLayoutAnimationEnabledExperimental() {}
+};

package/dist/cjs/modules/canUseDOM.cjs

@@ -0,0 +1,28 @@
+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 canUseDOM_exports = {};
+__export(canUseDOM_exports, {
+  canUseDOM: () => canUseDOM
+});
+module.exports = __toCommonJS(canUseDOM_exports);
+const canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);