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

package/dist/extractor/loadHanzogui.cjs

@@ -0,0 +1,367 @@
+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 loadHanzogui_exports = {};
+__export(loadHanzogui_exports, {
+  esbuildWatchFiles: () => esbuildWatchFiles,
+  generateThemesAndLog: () => generateThemesAndLog,
+  getOptions: () => getOptions,
+  loadHanzogui: () => loadHanzogui,
+  loadHanzoguiBuildConfigAsync: () => loadHanzoguiBuildConfigAsync,
+  loadHanzoguiBuildConfigSync: () => loadHanzoguiBuildConfigSync,
+  loadHanzoguiSync: () => loadHanzoguiSync,
+  resolveWebOrNativeSpecificEntry: () => resolveWebOrNativeSpecificEntry
+});
+module.exports = __toCommonJS(loadHanzogui_exports);
+var import_node_path = require("node:path");
+var import_cli_color = require("@hanzogui/cli-color");
+var import_esbuild = __toESM(require("esbuild"));
+var esbuildWasm = __toESM(require("esbuild-wasm"));
+var fsExtra = __toESM(require("fs-extra"));
+var import_constants = require("../constants.cjs");
+var import_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
+var import_registerRequire = require("../registerRequire.cjs");
+var import_bundleConfig = require("./bundleConfig.cjs");
+var import_getHanzoguiConfigPathFromOptionsConfig = require("./getHanzoguiConfigPathFromOptionsConfig.cjs");
+var import_regenerateConfig = require("./regenerateConfig.cjs");
+const getFilledOptions = propsIn => ({
+  platform: "web",
+  config: "hanzogui.config.ts",
+  components: ["hanzogui"],
+  ...propsIn
+});
+let isLoadingPromise;
+async function loadHanzogui(propsIn) {
+  if (isLoadingPromise) return await isLoadingPromise;
+  let resolvePromise;
+  let rejectPromise;
+  isLoadingPromise = new Promise((res, rej) => {
+    resolvePromise = res;
+    rejectPromise = rej;
+  });
+  try {
+    const props = getFilledOptions(propsIn);
+    const bundleInfo = await (0, import_bundleConfig.getBundledConfig)(props);
+    if (!bundleInfo) {
+      console.warn(`No bundled config generated, maybe an error in bundling. Set DEBUG=hanzogui and re-run to get logs.`);
+      resolvePromise(null);
+      return null;
+    }
+    await generateThemesAndLog(props);
+    const maybeHanzoguiConfig = bundleInfo.hanzoguiConfig;
+    if (maybeHanzoguiConfig && !maybeHanzoguiConfig.parsed) {
+      const {
+        createHanzogui
+      } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
+      bundleInfo.hanzoguiConfig = createHanzogui(bundleInfo.hanzoguiConfig);
+    }
+    if (!(0, import_bundleConfig.hasBundledConfigChanged)()) {
+      resolvePromise(bundleInfo);
+      return bundleInfo;
+    }
+    await (0, import_regenerateConfig.regenerateConfig)(props, bundleInfo);
+    resolvePromise(bundleInfo);
+    return bundleInfo;
+  } catch (err) {
+    rejectPromise();
+    throw err;
+  } finally {
+    isLoadingPromise = null;
+  }
+}
+let waiting = false;
+const generateThemesAndLog = async (options, force = false) => {
+  if (waiting) return;
+  if (!options.themeBuilder) return;
+  try {
+    waiting = true;
+    await new Promise(res => setTimeout(res, 30));
+    if (await (0, import_regenerateConfig.generateHanzoguiThemes)(options, force)) {
+      (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [hanzogui] generated themes: ${(0, import_node_path.relative)(process.cwd(), options.themeBuilder.output)}`);
+      if (options.outputCSS) {
+        const loadedConfig = (0, import_bundleConfig.getLoadedConfig)();
+        if (loadedConfig) await (0, import_bundleConfig.writeHanzoguiCSS)(options.outputCSS, loadedConfig);
+      }
+    }
+  } finally {
+    waiting = false;
+  }
+};
+const last = {};
+const lastVersion = {};
+let esbuildWasmInitialized = false;
+async function loadHanzoguiBuildConfigAsync(hanzoguiOptions) {
+  const buildFilePath = hanzoguiOptions?.buildFile ?? "./hanzogui.build.ts";
+  const absolutePath = buildFilePath[0] === "." ? (0, import_node_path.join)(process.cwd(), buildFilePath) : buildFilePath;
+  if (fsExtra.existsSync(absolutePath)) try {
+    const source = await fsExtra.readFile(absolutePath, "utf-8");
+    if (!esbuildWasmInitialized) {
+      await esbuildWasm.initialize({});
+      esbuildWasmInitialized = true;
+    }
+    const result = await esbuildWasm.transform(source, {
+      loader: "ts",
+      format: "cjs",
+      target: "node18",
+      sourcefile: absolutePath
+    });
+    const module2 = {
+      exports: {}
+    };
+    new Function("module", "exports", "require", "process", result.code)(module2, module2.exports, require, process);
+    const out = module2.exports.default || module2.exports;
+    if (!out || typeof out !== "object") throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+    hanzoguiOptions = {
+      ...hanzoguiOptions,
+      ...out
+    };
+  } catch (err) {
+    console.error(`[hanzogui] Error loading ${buildFilePath}:`, err);
+    throw err;
+  }
+  if (!hanzoguiOptions) throw new Error(`No hanzogui build options found either via input props or at hanzogui.build.ts`);
+  return {
+    config: "hanzogui.config.ts",
+    components: ["hanzogui", "@hanzogui/core"],
+    ...hanzoguiOptions
+  };
+}
+function loadHanzoguiBuildConfigSync(hanzoguiOptions) {
+  const buildFilePath = hanzoguiOptions?.buildFile ?? "./hanzogui.build.ts";
+  if (fsExtra.existsSync(buildFilePath)) {
+    const registered = (0, import_registerRequire.registerRequire)("web");
+    try {
+      const out = (buildFilePath[0] === "." ? require((0, import_node_path.join)(process.cwd(), buildFilePath)) : require(buildFilePath)).default;
+      if (!out) throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+      hanzoguiOptions = {
+        ...hanzoguiOptions,
+        ...out
+      };
+    } finally {
+      registered.unregister();
+    }
+  }
+  if (!hanzoguiOptions) throw new Error(`No hanzogui build options found either via input props or at hanzogui.build.ts`);
+  return {
+    config: "hanzogui.config.ts",
+    components: ["hanzogui", "@hanzogui/core"],
+    ...hanzoguiOptions
+  };
+}
+function loadHanzoguiSync({
+  forceExports,
+  cacheKey,
+  ...propsIn
+}) {
+  const key = JSON.stringify(propsIn);
+  if (last[key] && !(0, import_bundleConfig.hasBundledConfigChanged)()) {
+    if (!lastVersion[key] || lastVersion[key] === cacheKey) return last[key];
+  }
+  lastVersion[key] = cacheKey || "";
+  const props = getFilledOptions(propsIn);
+  process.env.IS_STATIC = "is_static";
+  process.env.TAMAGUI_IS_SERVER = "true";
+  const {
+    unregister
+  } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
+    proxyWormImports: !!forceExports
+  });
+  try {
+    const devValueOG = globalThis["__DEV__"];
+    globalThis["__DEV__"] = process.env.NODE_ENV === "development";
+    try {
+      let hanzoguiConfig = null;
+      if (propsIn.config) {
+        const configPath = (0, import_getHanzoguiConfigPathFromOptionsConfig.getHanzoguiConfigPathFromOptionsConfig)(propsIn.config);
+        const exp = require(configPath);
+        if (!exp || exp._isProxyWorm) throw new Error(`Got a empty / proxied config!`);
+        hanzoguiConfig = exp["default"] || exp["config"] || exp;
+        if (!hanzoguiConfig || !hanzoguiConfig.parsed) {
+          const confPath = require.resolve(configPath);
+          throw new Error(`Can't find valid config in ${confPath}:
+          
+  Be sure you "export default" or "export const config" the config.`);
+        }
+        if (hanzoguiConfig) {
+          const {
+            createHanzogui
+          } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
+          createHanzogui(hanzoguiConfig);
+        }
+      }
+      const components = (0, import_bundleConfig.loadComponentsSync)(props, forceExports);
+      if (!components) throw new Error(`No components loaded`);
+      if (process.env.DEBUG === "hanzogui") console.info(`components`, components);
+      process.env.IS_STATIC = void 0;
+      globalThis["__DEV__"] = devValueOG;
+      const info = {
+        components,
+        hanzoguiConfig,
+        nameToPaths: (0, import_registerRequire.getNameToPaths)()
+      };
+      if (hanzoguiConfig) {
+        const {
+          outputCSS
+        } = props;
+        if (outputCSS) (0, import_bundleConfig.writeHanzoguiCSS)(outputCSS, hanzoguiConfig);
+        (0, import_regenerateConfig.regenerateConfigSync)(props, info);
+      }
+      last[key] = {
+        ...info,
+        cached: true
+      };
+      return info;
+    } catch (err) {
+      if (err instanceof Error) {
+        if (!import_constants.SHOULD_DEBUG && !forceExports) {
+          console.warn(`Error loading hanzogui.config.ts (set DEBUG=hanzogui to see full stack), running hanzogui without custom config`);
+          console.info(`
+
+    ${err.message}
+
+`);
+        } else if (import_constants.SHOULD_DEBUG) console.error(err);
+      } else console.error(`Error loading hanzogui.config.ts`, err);
+      return {
+        components: [],
+        hanzoguiConfig: null,
+        nameToPaths: {}
+      };
+    }
+  } finally {
+    unregister();
+  }
+}
+async function getOptions({
+  root = process.cwd(),
+  tsconfigPath = "tsconfig.json",
+  hanzoguiOptions,
+  host,
+  debug
+} = {}) {
+  const dotDir = (0, import_node_path.join)(root, ".hanzogui");
+  let pkgJson = {};
+  try {
+    pkgJson = await fsExtra.readJSON((0, import_node_path.join)(root, "package.json"));
+  } catch (err) {}
+  return {
+    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+    root,
+    host: host || "127.0.0.1",
+    pkgJson,
+    debug,
+    tsconfigPath,
+    hanzoguiOptions: {
+      platform: "web",
+      components: ["hanzogui"],
+      ...hanzoguiOptions,
+      config: hanzoguiOptions?.config ?? (await getDefaultHanzoguiConfigPath(root, hanzoguiOptions?.config))
+    },
+    paths: {
+      root,
+      dotDir,
+      conf: (0, import_node_path.join)(dotDir, "hanzogui.config.json"),
+      types: (0, import_node_path.join)(dotDir, "types.json")
+    }
+  };
+}
+function resolveWebOrNativeSpecificEntry(entry) {
+  const workspaceRoot = (0, import_node_path.resolve)();
+  const resolved = require.resolve(entry, {
+    paths: [workspaceRoot]
+  });
+  const ext = (0, import_node_path.extname)(resolved);
+  const fileName = (0, import_node_path.basename)(resolved).replace(ext, "");
+  const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + ".web" + ext);
+  if (fsExtra.existsSync(specificFile)) return specificFile;
+  return entry;
+}
+const defaultPaths = ["hanzogui.config.ts", (0, import_node_path.join)("src", "hanzogui.config.ts")];
+let hasWarnedOnce = false;
+async function getDefaultHanzoguiConfigPath(root, configPath) {
+  const searchPaths = [...new Set([configPath, ...defaultPaths].filter(Boolean).map(p => (0, import_node_path.join)(root, p)))];
+  for (const path of searchPaths) if (await fsExtra.pathExists(path)) return path;
+  if (!hasWarnedOnce) {
+    hasWarnedOnce = true;
+    console.warn(`Warning: couldn't find hanzogui.config.ts in the following paths given configuration "${configPath}":
+    ${searchPaths.join(`
+  `)}
+  `);
+  }
+}
+async function esbuildWatchFiles(entry, onChanged) {
+  let hasRunOnce = false;
+  const context = await import_esbuild.default.context({
+    bundle: true,
+    entryPoints: [entry],
+    resolveExtensions: [".ts", ".tsx", ".js", ".mjs"],
+    logLevel: "silent",
+    write: false,
+    alias: {
+      "@react-native/normalize-color": "@hanzogui/proxy-worm",
+      "react-native-web": "@hanzogui/react-native-web-lite",
+      "react-native": "@hanzogui/proxy-worm"
+    },
+    plugins: [
+    // to log what its watching:
+    // {
+    //   name: 'test',
+    //   setup({ onResolve }) {
+    //     onResolve({ filter: /.*/ }, (args) => {
+    //       console.log('wtf', args.path)
+    //     })
+    //   },
+    // },
+    {
+      name: `on-rebuild`,
+      setup({
+        onEnd,
+        onResolve
+      }) {
+        onResolve({
+          filter: /^[^./]|^\.[^./]|^\.\.[^/]/
+        }, args => ({
+          path: args.path,
+          external: true
+        }));
+        onEnd(() => {
+          if (!hasRunOnce) hasRunOnce = true;else onChanged();
+        });
+      }
+    }]
+  });
+  context.watch();
+  return () => {
+    context.dispose();
+  };
+}

package/dist/extractor/logLines.cjs

@@ -0,0 +1,43 @@
+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 logLines_exports = {};
+__export(logLines_exports, {
+  logLines: () => logLines
+});
+module.exports = __toCommonJS(logLines_exports);
+const prefix = "           ";
+const logLines = (str, singleLine = false) => {
+  if (singleLine) {
+    return prefix + str.split(" ").join(`
+${prefix}`);
+  }
+  const lines = [""];
+  const items = str.split(" ");
+  for (const item of items) {
+    if (item.length + lines[lines.length - 1].length > 85) {
+      lines.push("");
+    }
+    lines[lines.length - 1] += item + " ";
+  }
+  return lines.map((line, i) => prefix + (i == 0 ? "" : " ") + line.trim()).join("\n");
+};

package/dist/extractor/normalizeTernaries.cjs

@@ -0,0 +1,95 @@
+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 normalizeTernaries_exports = {};
+__export(normalizeTernaries_exports, {
+  normalizeTernaries: () => normalizeTernaries
+});
+module.exports = __toCommonJS(normalizeTernaries_exports);
+var import_generator = __toESM(require("@babel/generator"));
+var t = __toESM(require("@babel/types"));
+var import_web = require("@hanzogui/web");
+var import_invariant = __toESM(require("invariant"));
+var import_propsToFontFamilyCache = require("./propsToFontFamilyCache.cjs");
+function normalizeTernaries(ternaries) {
+  (0, import_invariant.default)(Array.isArray(ternaries), "extractStaticTernaries expects param 1 to be an array of ternaries");
+  if (ternaries.length === 0) {
+    return [];
+  }
+  const ternariesByKey = {};
+  for (let idx = -1, len = ternaries.length; ++idx < len;) {
+    const {
+      test,
+      consequent,
+      alternate,
+      remove,
+      ...rest
+    } = ternaries[idx];
+    let ternaryTest = test;
+    if (t.isExpressionStatement(test)) {
+      ternaryTest = test.expression;
+    }
+    let shouldSwap = false;
+    if (t.isUnaryExpression(test) && test.operator === "!") {
+      ternaryTest = test.argument;
+      shouldSwap = true;
+    } else if (t.isBinaryExpression(test)) {
+      if (test.operator === "!==" || test.operator === "!=") {
+        ternaryTest = t.binaryExpression(test.operator.replace("!", "="), test.left, test.right);
+        shouldSwap = true;
+      }
+    }
+    const key = (0, import_generator.default)(ternaryTest).code;
+    if (!ternariesByKey[key]) {
+      ternariesByKey[key] = {
+        ...rest,
+        alternate: {},
+        consequent: {},
+        test: ternaryTest,
+        remove
+      };
+    }
+    const altStyle = (shouldSwap ? consequent : alternate) ?? {};
+    const consStyle = (shouldSwap ? alternate : consequent) ?? {};
+    const nextAlt = ternariesByKey[key].alternate;
+    ternariesByKey[key].alternate = (0, import_web.mergeProps)(altStyle, nextAlt);
+    (0, import_propsToFontFamilyCache.forwardFontFamilyName)(altStyle, ternariesByKey[key].alternate);
+    const nextCons = ternariesByKey[key].consequent;
+    ternariesByKey[key].consequent = (0, import_web.mergeProps)(consStyle, nextCons);
+    (0, import_propsToFontFamilyCache.forwardFontFamilyName)(consStyle, ternariesByKey[key].consequent);
+  }
+  const ternaryExpression = Object.keys(ternariesByKey).map(key => {
+    return ternariesByKey[key];
+  });
+  return ternaryExpression;
+}

package/dist/extractor/propsToFontFamilyCache.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 propsToFontFamilyCache_exports = {};
+__export(propsToFontFamilyCache_exports, {
+  forwardFontFamilyName: () => forwardFontFamilyName,
+  getFontFamilyNameFromProps: () => getFontFamilyNameFromProps,
+  setPropsToFontFamily: () => setPropsToFontFamily
+});
+module.exports = __toCommonJS(propsToFontFamilyCache_exports);
+const cache = /* @__PURE__ */new WeakMap();
+function setPropsToFontFamily(props, ff) {
+  cache.set(props, ff.replace("$", "").trim());
+}
+function getFontFamilyNameFromProps(props) {
+  return cache.get(props);
+}
+function forwardFontFamilyName(prev, next, fallback) {
+  const ff = getFontFamilyNameFromProps(prev) || fallback;
+  if (ff) {
+    setPropsToFontFamily(next, ff);
+  }
+}