@vxrn/compiler 1.1.397

package/dist/cjs/index.native.js

@@ -0,0 +1,123 @@
+"use strict";
+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;
+}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var index_exports = {};
+__export(index_exports, {
+  createVXRNCompilerPlugin: () => createVXRNCompilerPlugin
+});
+module.exports = __toCommonJS(index_exports);
+var import_utils = require("@vxrn/utils"), import_node_fs = require("node:fs"), import_promises = require("node:fs/promises"), import_node_path = require("node:path"), import_constants = require("./constants"), import_transformBabel = require("./transformBabel"), import_transformSWC = require("./transformSWC");
+__reExport(index_exports, require("./configure"), module.exports);
+__reExport(index_exports, require("./transformBabel"), module.exports);
+__reExport(index_exports, require("./transformSWC"), module.exports);
+const import_meta = {};
+async function createVXRNCompilerPlugin(optionsIn) {
+  var reactVersion = await async function() {
+    var path = (0, import_utils.resolvePath)("react/package.json"), json = JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
+    return json.version;
+  }(), envNames = {
+    ios: !0,
+    android: !0,
+    client: !0,
+    ssr: !0
+  };
+  function getEnvName(name) {
+    if (!envNames[name]) throw new Error(`Invalid env: ${name}`);
+    return name;
+  }
+  return [
+    {
+      name: "one:compiler-resolve-refresh-runtime",
+      apply: "serve",
+      enforce: "pre",
+      // Run before Vite default resolve to avoid syscalls
+      resolveId: function(id) {
+        return id === import_constants.runtimePublicPath ? id : void 0;
+      },
+      load: function(id) {
+        return id === import_constants.runtimePublicPath ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(import_meta.dirname, "refresh-runtime.js"), "utf-8") : void 0;
+      }
+    },
+    {
+      name: "one:compiler",
+      enforce: "pre",
+      config: function() {
+        var config = {
+          esbuild: !1,
+          optimizeDeps: {
+            noDiscovery: !0
+          }
+        };
+        return {
+          environments: {
+            ios: config,
+            android: config
+          }
+        };
+      },
+      transform: {
+        order: "pre",
+        async handler(codeIn, _id) {
+          var _optionsIn_transform, code = codeIn, shouldDebug = process.env.NODE_ENV === "development" && codeIn.startsWith("// debug");
+          shouldDebug && (console.info(`[one] ${_id} input:`), console.info(codeIn));
+          var extension = (0, import_node_path.extname)(_id);
+          if (import_constants.validParsers.has(extension)) {
+            var id = _id.split("?")[0], isPreProcess = id.startsWith("vxrn-swc-preprocess:");
+            if (isPreProcess && (id = id.replace("vxrn-swc-preprocess:", "")), !id.includes("virtual:")) {
+              var environment = getEnvName(this.environment.name), production = process.env.NODE_ENV === "production", transformProps = {
+                id,
+                code,
+                development: !production,
+                environment,
+                reactForRNVersion: reactVersion.split(".")[0]
+              }, userTransform = optionsIn == null || (_optionsIn_transform = optionsIn.transform) === null || _optionsIn_transform === void 0 ? void 0 : _optionsIn_transform.call(optionsIn, transformProps);
+              if (userTransform !== !1) {
+                if (!isPreProcess && userTransform !== "swc") {
+                  var babelOptions = (0, import_transformBabel.getBabelOptions)({
+                    ...transformProps,
+                    userSetting: userTransform
+                  });
+                  if (babelOptions) {
+                    var babelOut = await (0, import_transformBabel.transformBabel)(id, code, babelOptions);
+                    babelOut && (import_constants.debug === null || import_constants.debug === void 0 || (0, import_constants.debug)(`[${id}] transformed with babel options: ${JSON.stringify(babelOptions)}`), code = babelOut);
+                  }
+                }
+                var swcOptions = {
+                  environment,
+                  mode: "serve",
+                  production,
+                  ...optionsIn
+                }, out = await (0, import_transformSWC.transformSWC)(id, code, {
+                  ...swcOptions,
+                  es5: !0,
+                  noHMR: isPreProcess
+                });
+                return shouldDebug && (console.info("swcOptions", swcOptions), console.info("final output:", out == null ? void 0 : out.code)), out;
+              }
+            }
+          }
+        }
+      }
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createVXRNCompilerPlugin,
+  ...require("./configure"),
+  ...require("./transformBabel"),
+  ...require("./transformSWC")
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/Users/n8/one/packages/compiler/src/index.ts"],
+  "mappings": "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",
+  "names": ["createVXRNCompilerPlugin", "optionsIn", "reactVersion", "path", "resolvePath", "json", "JSON", "parse", "readFile", "version", "envNames", "ios", "android", "client", "ssr", "getEnvName", "name", "Error", "apply", "enforce", "resolveId", "id", "runtimePublicPath", "undefined", "load", "readFileSync", "join", "dirname", "config", "esbuild", "optimizeDeps", "noDiscovery", "environments", "transform", "order", "handler", "codeIn", "_id", "code", "shouldDebug", "process", "env", "NODE_ENV", "startsWith", "console", "info", "extension", "extname", "validParsers", "has", "split", "isPreProcess", "replace", "includes", "environment", "production", "transformProps", "development", "reactForRNVersion", "userTransform", "babelOptions", "getBabelOptions", "userSetting", "babelOut", "transformBabel", "debug", "stringify", "swcOptions", "mode", "out", "transformSWC", "es5", "noHMR"]
+}

package/dist/cjs/refresh-runtime.cjs

@@ -0,0 +1,295 @@
+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 refresh_runtime_exports = {};
+__export(refresh_runtime_exports, {
+  __hmr_import: () => __hmr_import,
+  createSignatureFunctionForTransform: () => createSignatureFunctionForTransform,
+  default: () => refresh_runtime_default,
+  getRefreshReg: () => getRefreshReg,
+  injectIntoGlobalHook: () => injectIntoGlobalHook,
+  registerExportsForReactRefresh: () => registerExportsForReactRefresh,
+  validateRefreshBoundaryAndEnqueueUpdate: () => validateRefreshBoundaryAndEnqueueUpdate
+});
+module.exports = __toCommonJS(refresh_runtime_exports);
+/*! Copyright (c) Meta Platforms, Inc. and affiliates. **/
+const REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+  REACT_MEMO_TYPE = Symbol.for("react.memo");
+let allFamiliesByID = /* @__PURE__ */new Map(),
+  allFamiliesByType = /* @__PURE__ */new WeakMap(),
+  allSignaturesByType = /* @__PURE__ */new WeakMap();
+const updatedFamiliesByType = /* @__PURE__ */new WeakMap();
+let pendingUpdates = [];
+const helpersByRendererID = /* @__PURE__ */new Map(),
+  helpersByRoot = /* @__PURE__ */new Map(),
+  mountedRoots = /* @__PURE__ */new Set(),
+  failedRoots = /* @__PURE__ */new Set();
+let rootElements = /* @__PURE__ */new WeakMap(),
+  isPerformingRefresh = !1;
+function computeFullKey(signature) {
+  if (signature.fullKey !== null) return signature.fullKey;
+  let fullKey = signature.ownKey,
+    hooks2;
+  try {
+    hooks2 = signature.getCustomHooks();
+  } catch {
+    return signature.forceReset = !0, signature.fullKey = fullKey, fullKey;
+  }
+  for (let i = 0; i < hooks2.length; i++) {
+    const hook = hooks2[i];
+    if (typeof hook != "function") return signature.forceReset = !0, signature.fullKey = fullKey, fullKey;
+    const nestedHookSignature = allSignaturesByType.get(hook);
+    if (nestedHookSignature === void 0) continue;
+    const nestedHookKey = computeFullKey(nestedHookSignature);
+    nestedHookSignature.forceReset && (signature.forceReset = !0), fullKey += `
+---
+` + nestedHookKey;
+  }
+  return signature.fullKey = fullKey, fullKey;
+}
+function haveEqualSignatures(prevType, nextType) {
+  const prevSignature = allSignaturesByType.get(prevType),
+    nextSignature = allSignaturesByType.get(nextType);
+  return prevSignature === void 0 && nextSignature === void 0 ? !0 : !(prevSignature === void 0 || nextSignature === void 0 || computeFullKey(prevSignature) !== computeFullKey(nextSignature) || nextSignature.forceReset);
+}
+function isReactClass(type) {
+  return type.prototype && type.prototype.isReactComponent;
+}
+function canPreserveStateBetween(prevType, nextType) {
+  return isReactClass(prevType) || isReactClass(nextType) ? !1 : !!haveEqualSignatures(prevType, nextType);
+}
+function resolveFamily(type) {
+  return updatedFamiliesByType.get(type);
+}
+function getProperty(object, property) {
+  try {
+    return object[property];
+  } catch {
+    return;
+  }
+}
+function performReactRefresh() {
+  if (pendingUpdates.length === 0 || isPerformingRefresh) return null;
+  isPerformingRefresh = !0;
+  try {
+    const staleFamilies = /* @__PURE__ */new Set(),
+      updatedFamilies = /* @__PURE__ */new Set(),
+      updates = pendingUpdates;
+    pendingUpdates = [], updates.forEach(([family, nextType]) => {
+      const prevType = family.current;
+      updatedFamiliesByType.set(prevType, family), updatedFamiliesByType.set(nextType, family), family.current = nextType, canPreserveStateBetween(prevType, nextType) ? updatedFamilies.add(family) : staleFamilies.add(family);
+    });
+    const update = {
+      updatedFamilies,
+      // Families that will re-render preserving state
+      staleFamilies
+      // Families that will be remounted
+    };
+    helpersByRendererID.forEach(helpers => {
+      helpers.setRefreshHandler(resolveFamily);
+    });
+    let didError = !1,
+      firstError = null;
+    const failedRootsSnapshot = new Set(failedRoots),
+      mountedRootsSnapshot = new Set(mountedRoots),
+      helpersByRootSnapshot = new Map(helpersByRoot);
+    if (failedRootsSnapshot.forEach(root => {
+      const helpers = helpersByRootSnapshot.get(root);
+      if (helpers === void 0) throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");
+      if (failedRoots.has(root), rootElements === null || !rootElements.has(root)) return;
+      const element = rootElements.get(root);
+      try {
+        helpers.scheduleRoot(root, element);
+      } catch (err) {
+        didError || (didError = !0, firstError = err);
+      }
+    }), mountedRootsSnapshot.forEach(root => {
+      const helpers = helpersByRootSnapshot.get(root);
+      if (helpers === void 0) throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");
+      mountedRoots.has(root);
+      try {
+        helpers.scheduleRefresh(root, update);
+      } catch (err) {
+        didError || (didError = !0, firstError = err);
+      }
+    }), didError) throw firstError;
+    return update;
+  } finally {
+    isPerformingRefresh = !1;
+  }
+}
+function register(type, id) {
+  if (type === null || typeof type != "function" && typeof type != "object" || allFamiliesByType.has(type)) return;
+  let family = allFamiliesByID.get(id);
+  if (family === void 0 ? (family = {
+    current: type
+  }, allFamiliesByID.set(id, family)) : pendingUpdates.push([family, type]), allFamiliesByType.set(type, family), typeof type == "object" && type !== null) switch (getProperty(type, "$$typeof")) {
+    case REACT_FORWARD_REF_TYPE:
+      register(type.render, id + "$render");
+      break;
+    case REACT_MEMO_TYPE:
+      register(type.type, id + "$type");
+      break;
+  }
+}
+function setSignature(type, key, forceReset, getCustomHooks) {
+  if (allSignaturesByType.has(type) || allSignaturesByType.set(type, {
+    forceReset,
+    ownKey: key,
+    fullKey: null,
+    getCustomHooks: getCustomHooks || (() => [])
+  }), typeof type == "object" && type !== null) switch (getProperty(type, "$$typeof")) {
+    case REACT_FORWARD_REF_TYPE:
+      setSignature(type.render, key, forceReset, getCustomHooks);
+      break;
+    case REACT_MEMO_TYPE:
+      setSignature(type.type, key, forceReset, getCustomHooks);
+      break;
+  }
+}
+function collectCustomHooksForSignature(type) {
+  const signature = allSignaturesByType.get(type);
+  signature !== void 0 && computeFullKey(signature);
+}
+function injectIntoGlobalHook(globalObject) {
+  let hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook === void 0) {
+    let nextID = 0;
+    globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+      renderers: /* @__PURE__ */new Map(),
+      supportsFiber: !0,
+      inject: injected => nextID++,
+      onScheduleFiberRoot: (id, root, children) => {},
+      onCommitFiberRoot: (id, root, maybePriorityLevel, didError) => {},
+      onCommitFiberUnmount() {}
+    };
+  }
+  if (hook.isDisabled) {
+    console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
+    return;
+  }
+  const oldInject = hook.inject;
+  hook.inject = function (injected) {
+    const id = oldInject.apply(this, arguments);
+    return typeof injected.scheduleRefresh == "function" && typeof injected.setRefreshHandler == "function" && helpersByRendererID.set(id, injected), id;
+  }, hook.renderers.forEach((injected, id) => {
+    typeof injected.scheduleRefresh == "function" && typeof injected.setRefreshHandler == "function" && helpersByRendererID.set(id, injected);
+  });
+  const oldOnCommitFiberRoot = hook.onCommitFiberRoot,
+    oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || (() => {});
+  hook.onScheduleFiberRoot = function (id, root, children) {
+    return isPerformingRefresh || (failedRoots.delete(root), rootElements !== null && rootElements.set(root, children)), oldOnScheduleFiberRoot.apply(this, arguments);
+  }, hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) {
+    const helpers = helpersByRendererID.get(id);
+    if (helpers !== void 0) {
+      helpersByRoot.set(root, helpers);
+      const current = root.current,
+        alternate = current.alternate;
+      if (alternate !== null) {
+        const wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root),
+          isMounted = current.memoizedState != null && current.memoizedState.element != null;
+        !wasMounted && isMounted ? (mountedRoots.add(root), failedRoots.delete(root)) : wasMounted && isMounted || (wasMounted && !isMounted ? (mountedRoots.delete(root), didError ? failedRoots.add(root) : helpersByRoot.delete(root)) : !wasMounted && !isMounted && didError && failedRoots.add(root));
+      } else mountedRoots.add(root);
+    }
+    return oldOnCommitFiberRoot.apply(this, arguments);
+  };
+}
+function createSignatureFunctionForTransform() {
+  let savedType,
+    hasCustomHooks,
+    didCollectHooks = !1;
+  return (type, key, forceReset, getCustomHooks) => {
+    if (typeof key == "string") return savedType || (savedType = type, hasCustomHooks = typeof getCustomHooks == "function"), type != null && (typeof type == "function" || typeof type == "object") && setSignature(type, key, forceReset, getCustomHooks), type;
+    !didCollectHooks && hasCustomHooks && (didCollectHooks = !0, collectCustomHooksForSignature(savedType));
+  };
+}
+function isLikelyComponentType(type) {
+  switch (typeof type) {
+    case "function":
+      {
+        if (type.prototype != null) {
+          if (type.prototype.isReactComponent) return !0;
+          const ownNames = Object.getOwnPropertyNames(type.prototype);
+          if (ownNames.length > 1 || ownNames[0] !== "constructor" || type.prototype.__proto__ !== Object.prototype) return !1;
+        }
+        const name = type.name || type.displayName;
+        return typeof name == "string" && /^[A-Z]/.test(name);
+      }
+    case "object":
+      {
+        if (type != null) switch (getProperty(type, "$$typeof")) {
+          case REACT_FORWARD_REF_TYPE:
+          case REACT_MEMO_TYPE:
+            return !0;
+          default:
+            return !1;
+        }
+        return !1;
+      }
+    default:
+      return !1;
+  }
+}
+function getRefreshReg(filename) {
+  return (type, id) => register(type, filename + " " + id);
+}
+function registerExportsForReactRefresh(filename, moduleExports) {
+  for (const key in moduleExports) {
+    if (key === "__esModule") continue;
+    const exportValue = moduleExports[key];
+    isLikelyComponentType(exportValue) && register(exportValue, filename + " export " + key);
+  }
+}
+function debounce(fn, delay) {
+  let handle;
+  return () => {
+    clearTimeout(handle), handle = setTimeout(fn, delay);
+  };
+}
+const hooks = [];
+window.__registerBeforePerformReactRefresh = cb => {
+  hooks.push(cb);
+};
+const enqueueUpdate = debounce(async () => {
+  hooks.length && (await Promise.all(hooks.map(cb => cb()))), performReactRefresh();
+}, 16);
+function validateRefreshBoundaryAndEnqueueUpdate(id, prevExports, nextExports) {
+  const ignoredExports = window.__getReactRefreshIgnoredExports?.({
+    id
+  }) ?? [];
+  if (predicateOnExport(ignoredExports, prevExports, key => key in nextExports) !== !0) return "Could not Fast Refresh (export removed)";
+  if (predicateOnExport(ignoredExports, nextExports, key => key in prevExports) !== !0) return "Could not Fast Refresh (new export)";
+  let hasExports = !1;
+  const allExportsAreComponentsOrUnchanged = predicateOnExport(ignoredExports, nextExports, (key, value) => (hasExports = !0, isLikelyComponentType(value) ? !0 : prevExports[key] === nextExports[key]));
+  if (hasExports && allExportsAreComponentsOrUnchanged === !0) enqueueUpdate();else return `Could not Fast Refresh ("${allExportsAreComponentsOrUnchanged}" export is incompatible). Learn more at https://github.com/vitejs/vite-plugin-react-swc#consistent-components-exports`;
+}
+function predicateOnExport(ignoredExports, moduleExports, predicate) {
+  for (const key in moduleExports) {
+    if (key === "__esModule" || ignoredExports.includes(key)) continue;
+    const desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+    if (desc && desc.get || !predicate(key, moduleExports[key])) return key;
+  }
+  return !0;
+}
+const __hmr_import = module2 => import(/* @vite-ignore */
+module2);
+var refresh_runtime_default = {
+  injectIntoGlobalHook
+};