@hanzogui/react-native-web-internals 2.0.0

package/dist/cjs/modules/AccessibilityUtil/index.cjs

@@ -0,0 +1,33 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AccessibilityUtil_exports = {};
+__export(AccessibilityUtil_exports, {
+  AccessibilityUtil: () => AccessibilityUtil
+});
+module.exports = __toCommonJS(AccessibilityUtil_exports);
+var import_isDisabled = require("./isDisabled.cjs"),
+  import_propsToAccessibilityComponent = require("./propsToAccessibilityComponent.cjs"),
+  import_propsToAriaRole = require("./propsToAriaRole.cjs");
+const AccessibilityUtil = {
+  isDisabled: import_isDisabled.isDisabled,
+  propsToAccessibilityComponent: import_propsToAccessibilityComponent.propsToAccessibilityComponent,
+  propsToAriaRole: import_propsToAriaRole.propsToAriaRole
+};

package/dist/cjs/modules/AccessibilityUtil/isDisabled.cjs

@@ -0,0 +1,26 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var isDisabled_exports = {};
+__export(isDisabled_exports, {
+  isDisabled: () => isDisabled
+});
+module.exports = __toCommonJS(isDisabled_exports);
+const isDisabled = props => props.disabled || Array.isArray(props.accessibilityStates) && props.accessibilityStates.indexOf("disabled") > -1;

package/dist/cjs/modules/AccessibilityUtil/propsToAccessibilityComponent.cjs

@@ -0,0 +1,57 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var propsToAccessibilityComponent_exports = {};
+__export(propsToAccessibilityComponent_exports, {
+  propsToAccessibilityComponent: () => propsToAccessibilityComponent
+});
+module.exports = __toCommonJS(propsToAccessibilityComponent_exports);
+var import_propsToAriaRole = require("./propsToAriaRole.cjs");
+const roleComponents = {
+    article: "article",
+    banner: "header",
+    blockquote: "blockquote",
+    code: "code",
+    complementary: "aside",
+    contentinfo: "footer",
+    deletion: "del",
+    emphasis: "em",
+    figure: "figure",
+    insertion: "ins",
+    form: "form",
+    list: "ul",
+    listitem: "li",
+    main: "main",
+    navigation: "nav",
+    region: "section",
+    strong: "strong"
+  },
+  emptyObject = {},
+  propsToAccessibilityComponent = (props = emptyObject) => {
+    if (props.accessibilityRole === "label") return "label";
+    const role = (0, import_propsToAriaRole.propsToAriaRole)(props);
+    if (role) {
+      if (role === "heading") {
+        const level = props.accessibilityLevel || props["aria-level"];
+        return level != null ? `h${level}` : "h1";
+      }
+      return roleComponents[role];
+    }
+  };

package/dist/cjs/modules/AccessibilityUtil/propsToAriaRole.cjs

@@ -0,0 +1,47 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var propsToAriaRole_exports = {};
+__export(propsToAriaRole_exports, {
+  propsToAriaRole: () => propsToAriaRole
+});
+module.exports = __toCommonJS(propsToAriaRole_exports);
+const accessibilityRoleToWebRole = {
+    adjustable: "slider",
+    button: "button",
+    header: "heading",
+    image: "img",
+    imagebutton: null,
+    keyboardkey: null,
+    label: null,
+    link: "link",
+    none: "presentation",
+    search: "search",
+    summary: "region",
+    text: null
+  },
+  propsToAriaRole = ({
+    accessibilityRole
+  }) => {
+    if (accessibilityRole) {
+      const inferredRole = accessibilityRoleToWebRole[accessibilityRole];
+      if (inferredRole !== null) return inferredRole || accessibilityRole;
+    }
+  };

package/dist/cjs/modules/AssetRegistry/index.cjs

@@ -0,0 +1,33 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AssetRegistry_exports = {};
+__export(AssetRegistry_exports, {
+  getAssetByID: () => getAssetByID,
+  registerAsset: () => registerAsset
+});
+module.exports = __toCommonJS(AssetRegistry_exports);
+const assets = [];
+function registerAsset(asset) {
+  return assets.push(asset);
+}
+function getAssetByID(assetId) {
+  return assets[assetId - 1];
+}

package/dist/cjs/modules/ImageLoader/index.cjs

@@ -0,0 +1,111 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var ImageLoader_exports = {};
+__export(ImageLoader_exports, {
+  ImageLoader: () => ImageLoader,
+  ImageUriCache: () => ImageUriCache
+});
+module.exports = __toCommonJS(ImageLoader_exports);
+const dataUriPattern = /^data:/;
+class ImageUriCache {
+  static _maximumEntries = 256;
+  static _entries = {};
+  static has(uri) {
+    const entries = ImageUriCache._entries;
+    return dataUriPattern.test(uri) || !!entries[uri];
+  }
+  static add(uri) {
+    const entries = ImageUriCache._entries,
+      lastUsedTimestamp = Date.now();
+    entries[uri] ? (entries[uri].lastUsedTimestamp = lastUsedTimestamp, entries[uri].refCount += 1) : entries[uri] = {
+      lastUsedTimestamp,
+      refCount: 1
+    };
+  }
+  static remove(uri) {
+    const entries = ImageUriCache._entries;
+    entries[uri] && (entries[uri].refCount -= 1), ImageUriCache._cleanUpIfNeeded();
+  }
+  static _cleanUpIfNeeded() {
+    const entries = ImageUriCache._entries,
+      imageUris = Object.keys(entries);
+    if (imageUris.length + 1 > ImageUriCache._maximumEntries) {
+      let leastRecentlyUsedKey, leastRecentlyUsedEntry;
+      imageUris.forEach(uri => {
+        const entry = entries[uri];
+        (!leastRecentlyUsedEntry || entry.lastUsedTimestamp < leastRecentlyUsedEntry.lastUsedTimestamp) && entry.refCount === 0 && (leastRecentlyUsedKey = uri, leastRecentlyUsedEntry = entry);
+      }), leastRecentlyUsedKey && delete entries[leastRecentlyUsedKey];
+    }
+  }
+}
+let id = 0;
+const requests = {},
+  ImageLoader = {
+    abort(requestId) {
+      let image = requests[`${requestId}`];
+      image && (image.onerror = null, image.onload = null, image = null, delete requests[`${requestId}`]);
+    },
+    getSize(uri, success, failure) {
+      let complete = !1;
+      const interval = setInterval(callback, 16),
+        requestId = ImageLoader.load(uri, callback, errorCallback);
+      function callback() {
+        const image = requests[`${requestId}`];
+        if (image) {
+          const {
+            naturalHeight,
+            naturalWidth
+          } = image;
+          naturalHeight && naturalWidth && (success(naturalWidth, naturalHeight), complete = !0);
+        }
+        complete && (ImageLoader.abort(requestId), clearInterval(interval));
+      }
+      function errorCallback() {
+        typeof failure == "function" && failure(), ImageLoader.abort(requestId), clearInterval(interval);
+      }
+    },
+    has(uri) {
+      return ImageUriCache.has(uri);
+    },
+    load(uri, onLoad, onError) {
+      id += 1;
+      const image = new window.Image();
+      return image.onerror = onError, image.onload = e => {
+        const onDecode = () => onLoad({
+          nativeEvent: e
+        });
+        typeof image.decode == "function" ? image.decode().then(onDecode, onDecode) : setTimeout(onDecode, 0);
+      }, image.src = uri, requests[`${id}`] = image, id;
+    },
+    prefetch(uri) {
+      return new Promise((resolve, reject) => {
+        ImageLoader.load(uri, () => {
+          ImageUriCache.add(uri), ImageUriCache.remove(uri), resolve();
+        }, reject);
+      });
+    },
+    queryCache(uris) {
+      const result = {};
+      return uris.forEach(u => {
+        ImageUriCache.has(u) && (result[u] = "disk/memory");
+      }), Promise.resolve(result);
+    }
+  };

package/dist/cjs/modules/InteractionManager.cjs

@@ -0,0 +1,184 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var InteractionManager_exports = {};
+__export(InteractionManager_exports, {
+  InteractionManager: () => InteractionManager
+});
+module.exports = __toCommonJS(InteractionManager_exports);
+var import_invariant = require("./invariant.cjs"),
+  import_requestIdleCallback = require("./requestIdleCallback/index.cjs");
+class EventEmitter {
+  _registry = {};
+  addListener(eventType, listener, context) {
+    const registrations = this._allocate(eventType),
+      registration = {
+        context,
+        listener,
+        remove: () => {
+          registrations.delete(registration);
+        }
+      };
+    return registrations.add(registration), 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];
+    return registrations == null && (registrations = /* @__PURE__ */new Set(), this._registry[eventType] = registrations), registrations;
+  }
+}
+class TaskQueue {
+  _queueStack;
+  _onMoreTasks;
+  constructor({
+    onMoreTasks
+  }) {
+    this._onMoreTasks = onMoreTasks, this._queueStack = [{
+      tasks: [],
+      popable: !0
+    }];
+  }
+  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 {
+        typeof task == "object" && task && "gen" in task ? this._genPromise(task) : typeof task == "object" && task && "run" in task ? task.run() : ((0, import_invariant.invariant)(typeof task == "function", `Expected Function, SimpleTask, or PromiseTask, but got:
+` + 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,
+      queue = this._queueStack[stackIdx];
+    return queue.popable && queue.tasks.length === 0 && stackIdx > 0 ? (this._queueStack.pop(), this._getCurrentQueue()) : queue.tasks;
+  }
+  _genPromise(task) {
+    const stackIdx = this._queueStack.push({
+        tasks: [],
+        popable: !1
+      }) - 1,
+      stackItem = this._queueStack[stackIdx];
+    task.gen().then(() => {
+      stackItem.popable = !0, this.hasTasksToProcess() && this._onMoreTasks();
+    }).catch(ex => {
+      setTimeout(() => {
+        throw ex instanceof Error && (ex.message = `TaskQueue: Error resolving Promise in task ${task.name}: ${ex.message}`), ex;
+      }, 0);
+    });
+  }
+}
+const _emitter = new EventEmitter(),
+  InteractionManager = {
+    Events: {
+      interactionStart: "interactionStart",
+      interactionComplete: "interactionComplete"
+    },
+    /**
+     * Schedule a function to run after all interactions have completed.
+     */
+    runAfterInteractions(task) {
+      const tasks = [],
+        promise = new Promise(resolve => {
+          _scheduleUpdate(), 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;
+      return _addInteractionSet.add(handle), 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;
+    }
+  },
+  _interactionSet = /* @__PURE__ */new Set(),
+  _addInteractionSet = /* @__PURE__ */new Set(),
+  _deleteInteractionSet = /* @__PURE__ */new Set(),
+  _taskQueue = new TaskQueue({
+    onMoreTasks: _scheduleUpdate
+  });
+let _nextUpdateHandle = null,
+  _inc = 0,
+  _deadline = -1;
+function _scheduleUpdate() {
+  _nextUpdateHandle || (_deadline > 0 ? _nextUpdateHandle = setTimeout(_processUpdate) : _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") : interactionCount === 0 && nextInteractionCount !== 0 && _emitter.emit("interactionStart"), nextInteractionCount === 0) {
+    const begin = Date.now();
+    for (; _taskQueue.hasTasksToProcess();) if (_taskQueue.processNext(), _deadline > 0 && Date.now() - begin >= _deadline) {
+      _scheduleUpdate();
+      break;
+    }
+  }
+  _addInteractionSet.clear(), _deleteInteractionSet.clear();
+}

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

@@ -0,0 +1,48 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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;
+};
+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: !0
+}) : 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(!0);
+    }), test('false when NODE_ENV is not "test"', () => {
+      process.env.NODE_ENV = "development", expect(import__.default.isTesting).toEqual(!1);
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), 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,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: !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;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), 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() {
+    return document.activeElement !== this._currentlyFocusedNode && (this._currentlyFocusedNode = null), 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) {
+    textFieldNode !== null && (this._currentlyFocusedNode = textFieldNode, 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) {
+    textFieldNode !== null && (this._currentlyFocusedNode = null, document.activeElement === textFieldNode && import_UIManager.UIManager.blur(textFieldNode));
+  }
+};