@hanzogui/static 2.0.0-rc.41-hanzoai.5

package/dist/registerRequire.cjs

@@ -0,0 +1,208 @@
+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 registerRequire_exports = {};
+__export(registerRequire_exports, {
+  getNameToPaths: () => getNameToPaths,
+  registerRequire: () => registerRequire,
+  setRequireResult: () => setRequireResult
+});
+module.exports = __toCommonJS(registerRequire_exports);
+var import_node = require("esbuild-register/dist/node");
+var import_bundle = require("./extractor/bundle.cjs");
+var import_requireHanzoguiCore = require("./helpers/requireHanzoguiCore.cjs");
+const nameToPaths = {};
+const getNameToPaths = () => nameToPaths;
+const Module = require("node:module");
+const proxyWorm = require("@hanzogui/proxy-worm");
+let isRegistered = false;
+let og;
+const whitelisted = {
+  react: true
+};
+const compiled = {};
+function setRequireResult(name, result) {
+  compiled[name] = result;
+}
+function getStaticExtractionStub(path) {
+  switch (path) {
+    case "expo-constants":
+      return {
+        __esModule: true,
+        default: {
+          executionEnvironment: null
+        },
+        ExecutionEnvironment: {
+          Bare: "bare",
+          Standalone: "standalone",
+          StoreClient: "storeClient"
+        }
+      };
+    case "expo-updates":
+      return {
+        __esModule: true,
+        default: {
+          isEnabled: false,
+          isUsingEmbeddedAssets: true
+        },
+        checkForUpdateAsync: async () => ({
+          isAvailable: false
+        }),
+        fetchUpdateAsync: async () => ({
+          isNew: false
+        }),
+        reloadAsync: async () => {}
+      };
+    default:
+      return null;
+  }
+}
+function registerRequire(platform, {
+  proxyWormImports
+} = {
+  proxyWormImports: false
+}) {
+  if (isRegistered) {
+    return {
+      hanzoguiRequire: require,
+      unregister: () => {}
+    };
+  }
+  const originalResolveFilename = Module._resolveFilename;
+  const {
+    unregister
+  } = (0, import_node.register)({
+    hookIgnoreNodeModules: false,
+    // don't transform @hanzogui packages - they have pre-built dist files
+    hookMatcher: filename => {
+      if (filename.includes("@hanzogui") || /\/hanzogui\/code\/(core|ui|packages)\//.test(filename)) {
+        return false;
+      }
+      return true;
+    }
+  });
+  const tsconfigPatchedResolve = Module._resolveFilename;
+  Module._resolveFilename = function (request, ...args) {
+    if (request.startsWith("@hanzogui/")) {
+      return originalResolveFilename.call(this, request, ...args);
+    }
+    return tsconfigPatchedResolve.call(this, request, ...args);
+  };
+  if (!og) {
+    og = Module.prototype.require;
+  }
+  isRegistered = true;
+  Module.prototype.require = hanzoguiRequire;
+  function hanzoguiRequire(path) {
+    const staticExtractionStub = getStaticExtractionStub(path);
+    if (staticExtractionStub) {
+      return staticExtractionStub;
+    }
+    if (path === "hanzogui" && platform === "native") {
+      return og.apply(this, ["hanzogui/native"]);
+    }
+    if (path === "@hanzogui/core") {
+      return (0, import_requireHanzoguiCore.requireHanzoguiCore)(platform, path2 => {
+        return og.apply(this, [path2]);
+      });
+    }
+    if (path in knownIgnorableModules || path.startsWith("react-native-reanimated") || import_bundle.esbuildIgnoreFilesRegex.test(path)) {
+      return proxyWorm;
+    }
+    if (path in compiled) {
+      return compiled[path];
+    }
+    if (path === "react-native-svg") {
+      return og.apply(this, ["@hanzogui/react-native-svg"]);
+    }
+    if (path === "react-native/package.json") {
+      return og.apply(this, ["react-native-web/package.json"]);
+    }
+    if (path === "@hanzogui/react-native-web-lite" || path === "react-native" || path.startsWith("react-native/")) {
+      try {
+        return og.apply("react-native");
+      } catch {
+        return og.apply(this, ["@hanzogui/react-native-web-lite"]);
+      }
+    }
+    if (!whitelisted[path]) {
+      if (proxyWormImports && !path.includes(".hanzogui-dynamic-eval")) {
+        const callerFile = this?.filename || this?.id || "";
+        const isFromHanzoguiPkg = callerFile.includes("@hanzogui") || callerFile.includes("node_modules/hanzogui/");
+        const isFromStaticLoader = !callerFile || callerFile === "." || callerFile === "[eval]" || callerFile.endsWith("/[eval]") || callerFile.includes("/code/compiler/static/") || callerFile.includes("/.hanzogui/");
+        if (path === "hanzogui" || path.startsWith("@hanzogui/") || isFromHanzoguiPkg || isFromStaticLoader) {
+          return og.apply(this, [path]);
+        }
+        return proxyWorm;
+      }
+    }
+    try {
+      const out = og.apply(this, arguments);
+      return out;
+    } catch (err) {
+      if (!process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && path.includes("hanzogui-dynamic-eval")) {
+        return;
+      }
+      if (allowedIgnores[path] || IGNORES === "true") {} else if (!process.env.TAMAGUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
+        if (hasWarnedForModules.has(path)) {} else {
+          hasWarnedForModules.add(path);
+        }
+      } else {
+        console.warn(`  [hanzogui] skipped "${path}" (set TAMAGUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`);
+      }
+      return proxyWorm;
+    }
+  }
+  return {
+    hanzoguiRequire,
+    unregister: () => {
+      if (hasWarnedForModules.size) {
+        console.info(`  [hanzogui] skipped loading ${hasWarnedForModules.size} module, see: https://hanzogui.dev/docs/intro/errors#warning-001`);
+        hasWarnedForModules.clear();
+      }
+      unregister();
+      isRegistered = false;
+      Module.prototype.require = og;
+    }
+  };
+}
+const IGNORES = process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS;
+const extraIgnores = IGNORES === "true" ? [] : process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS?.split(",");
+const knownIgnorableModules = {
+  "@gorhom/bottom-sheet": true,
+  "expo-modules": true,
+  solito: true,
+  "expo-linear-gradient": true,
+  "@expo/vector-icons": true,
+  "hanzogui/linear-gradient": true,
+  // animation libraries not needed for static extraction
+  "@emotion/is-prop-valid": true,
+  "framer-motion": true,
+  motion: true,
+  ...Object.fromEntries(extraIgnores?.map(k => [k, true]) || [])
+};
+const hasWarnedForModules = /* @__PURE__ */new Set();
+const allowedIgnores = {
+  "expo-constants": true,
+  "./ExpoHaptics": true,
+  "./js/MaskedView": true
+};

package/dist/server.cjs

@@ -0,0 +1,82 @@
+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 server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_node_net = __toESM(require("node:net"));
+async function startServer(options) {
+  const port = await getAvailablePort();
+  const server = import_node_net.default.createServer();
+  server.unref();
+  await new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.on("connection", conn => {
+      conn.on("data", data => {
+        console.info("got", data.toString());
+      });
+    });
+    server.listen({
+      port
+    }, () => {
+      const {
+        port: port2
+      } = server.address();
+      server.close(() => {
+        resolve(port2);
+      });
+    });
+  });
+}
+async function getAvailablePort(port = 8089) {
+  return checkAvailablePort(port).catch(() => getAvailablePort(port + 1));
+}
+function checkAvailablePort(port) {
+  return new Promise((resolve, reject) => {
+    const server = import_node_net.default.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen({
+      port
+    }, () => {
+      const {
+        port: port2
+      } = server.address();
+      server.close(() => {
+        resolve(port2);
+      });
+    });
+  });
+}

package/dist/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);

package/dist/worker.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: 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 worker_exports = {};
+__export(worker_exports, {
+  default: () => worker_default,
+  runTask: () => runTask
+});
+module.exports = __toCommonJS(worker_exports);
+var import_createExtractor = require("./extractor/createExtractor.cjs");
+var import_extractToClassNames = require("./extractor/extractToClassNames.cjs");
+var import_extractToNative = require("./extractor/extractToNative.cjs");
+let webExtractor = null;
+let nativeExtractor = null;
+function getWebExtractor() {
+  if (!webExtractor) {
+    webExtractor = (0, import_createExtractor.createExtractor)({
+      platform: "web"
+    });
+  }
+  return webExtractor;
+}
+function getNativeExtractor() {
+  if (!nativeExtractor) {
+    nativeExtractor = (0, import_createExtractor.createExtractor)({
+      platform: "native"
+    });
+  }
+  return nativeExtractor;
+}
+const configCache = /* @__PURE__ */new Map();
+async function runTask(task) {
+  try {
+    if (task.type === "extractToClassNames") {
+      const isFullyDisabled = task.options.disableExtraction && task.options.disableDebugAttr;
+      if (!isFullyDisabled && !task.options["_disableLoadHanzogui"]) {
+        const cacheKey = JSON.stringify({
+          config: task.options.config,
+          components: task.options.components
+        });
+        if (!configCache.has(cacheKey)) {
+          configCache.set(cacheKey, getWebExtractor().loadHanzogui(task.options));
+        }
+        await configCache.get(cacheKey);
+      }
+      const result = await (0, import_extractToClassNames.extractToClassNames)({
+        extractor: getWebExtractor(),
+        source: task.source,
+        sourcePath: task.sourcePath,
+        options: task.options,
+        shouldPrintDebug: task.shouldPrintDebug
+      });
+      return {
+        success: true,
+        data: result
+      };
+    }
+    if (task.type === "extractToNative") {
+      const cacheKey = JSON.stringify({
+        config: task.options.config,
+        components: task.options.components
+      });
+      if (!configCache.has(cacheKey)) {
+        configCache.set(cacheKey, getNativeExtractor().loadHanzogui(task.options));
+      }
+      await configCache.get(cacheKey);
+      const result = (0, import_extractToNative.extractToNative)(task.sourceFileName, task.sourceCode, task.options);
+      return {
+        success: true,
+        data: result
+      };
+    }
+    if (task.type === "clearCache") {
+      configCache.clear();
+      return {
+        success: true,
+        data: null
+      };
+    }
+    return {
+      success: false,
+      error: `Unknown task type: ${task.type}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    };
+  }
+}
+var worker_default = runTask;

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@hanzogui/static",
+  "version": "2.0.0-rc.41-hanzoai.5",
+  "gitHead": "a49cc7ea6b93ba384e77a4880ae48ac4a5635c14",
+  "license": "MIT",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "types",
+    "dist"
+  ],
+  "type": "commonjs",
+  "main": "dist",
+  "types": "./types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.cjs"
+    },
+    "./worker": {
+      "types": "./types/worker.d.ts",
+      "default": "./dist/worker.cjs"
+    },
+    "./checkDeps": {
+      "types": "./types/checkDeps.d.ts",
+      "default": "./dist/checkDeps.cjs"
+    },
+    "./loadHanzogui": {
+      "types": "./types/extractor/loadHanzogui.d.ts",
+      "default": "./dist/extractor/loadHanzogui.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "hanzogui-build --skip-native",
+    "watch": "hanzogui-build --skip-native --watch",
+    "clean": "hanzogui-build clean",
+    "clean:build": "hanzogui-build clean:build"
+  },
+  "dependencies": {
+    "@babel/core": "^7.25.2",
+    "@babel/generator": "^7.25.5",
+    "@babel/helper-plugin-utils": "^7.24.8",
+    "@babel/parser": "^7.25.4",
+    "@babel/plugin-transform-react-jsx": "^7.25.2",
+    "@babel/runtime": "^7.25.4",
+    "@babel/template": "^7.25.0",
+    "@babel/traverse": "^7.25.4",
+    "@babel/types": "^7.25.4",
+    "@hanzogui/cli-color": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/config-default": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/core": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/fake-react-native": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/generate-themes": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/helpers": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/helpers-node": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/proxy-worm": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/react-native-web-internals": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/react-native-web-lite": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/shorthands": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/types": "2.0.0-rc.41-hanzoai.5",
+    "@hanzogui/web": "2.0.0-rc.41-hanzoai.5",
+    "babel-literal-to-ast": "^2.1.0",
+    "browserslist": "^4.28.1",
+    "check-dependency-version-consistency": "^4.1.0",
+    "esbuild": "^0.27.2",
+    "esbuild-register": "^3.6.0",
+    "esbuild-wasm": "^0.27.2",
+    "fast-glob": "^3.2.11",
+    "find-cache-dir": "^3.3.2",
+    "find-root": "^1.1.0",
+    "fs-extra": "^11.2.0",
+    "invariant": "^2.2.4",
+    "js-yaml": "^4.1.0",
+    "react-native-web": "^0.21.0"
+  },
+  "devDependencies": {
+    "@babel/plugin-syntax-typescript": "^7.25.4",
+    "@hanzogui/build": "2.0.0-rc.41-hanzoai.5",
+    "@types/babel__core": "^7.20.5",
+    "@types/find-root": "^1.1.2",
+    "@types/node": "^22.1.0",
+    "@types/webpack": "^4.41.26",
+    "babel-loader": "^9.1.3",
+    "esbuild-loader": "^4.2.2",
+    "null-loader": "^4.0.1",
+    "react": ">=19",
+    "react-native": "0.83.2",
+    "typescript": "~5.9.2"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-native": "*"
+  },
+  "tests": {
+    "parallel": true
+  }
+}