@hanzogui/static 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+  Copyright (c) 2020 Nate Wienert
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+## static

package/dist/check-dep-versions.cjs

@@ -0,0 +1,267 @@
+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 check_dep_versions_exports = {};
+__export(check_dep_versions_exports, {
+  CDVC: () => CDVC
+});
+module.exports = __toCommonJS(check_dep_versions_exports);
+var import_fast_glob = require("fast-glob"),
+  import_js_yaml = require("js-yaml"),
+  import_node_fs = require("node:fs"),
+  import_node_path = require("node:path");
+function calculateVersionsForEachDependency(packages, depType = DEFAULT_DEP_TYPES) {
+  const dependenciesToVersionsSeen = /* @__PURE__ */new Map();
+  for (const package_ of packages) recordDependencyVersionsForPackageJson(dependenciesToVersionsSeen, package_, depType);
+  return dependenciesToVersionsSeen;
+}
+function recordDependencyVersionsForPackageJson(dependenciesToVersionsSeen, package_, depType) {
+  if (package_.packageJson.name && package_.packageJson.version && recordDependencyVersion(dependenciesToVersionsSeen, package_.packageJson.name, package_.packageJson.version, package_, !0), depType.includes("dependencies" /* dependencies */) && package_.packageJson.dependencies) for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.dependencies)) dependencyVersion && recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+  if (depType.includes("devDependencies" /* devDependencies */) && package_.packageJson.devDependencies) for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.devDependencies)) dependencyVersion && recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+  if (depType.includes("optionalDependencies" /* optionalDependencies */) && package_.packageJson.optionalDependencies) for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.optionalDependencies)) dependencyVersion && recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+  if (depType.includes("peerDependencies" /* peerDependencies */) && package_.packageJson.peerDependencies) for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.peerDependencies)) dependencyVersion && recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+  if (depType.includes("resolutions" /* resolutions */) && package_.packageJson.resolutions) for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.resolutions)) dependencyVersion && recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+}
+function recordDependencyVersion(dependenciesToVersionsSeen, dependency, version, package_, isLocalPackageVersion = !1) {
+  dependenciesToVersionsSeen.has(dependency) || dependenciesToVersionsSeen.set(dependency, []);
+  const list = dependenciesToVersionsSeen.get(dependency);
+  list && list.push({
+    package: package_,
+    version,
+    isLocalPackageVersion
+  });
+}
+function calculateDependenciesAndVersions(dependencyVersions) {
+  return [...dependencyVersions.entries()].sort((a, b) => a[0].localeCompare(b[0])).flatMap(([dependency, versionObjectsForDep]) => {
+    if (!versionObjectsForDep) return [];
+    let versions = versionObjectsForDep.filter(versionObject => !versionObject.isLocalPackageVersion).map(versionObject => versionObject.version);
+    const localPackageVersions = versionObjectsForDep.filter(versionObject => versionObject.isLocalPackageVersion).map(versionObject => versionObject.version),
+      allVersionsHaveWorkspacePrefix = versions.every(version => version.startsWith("workspace:")),
+      hasIncompatibilityWithLocalPackageVersion = versions.some(version => localPackageVersions[0] !== version);
+    localPackageVersions.length === 1 && !allVersionsHaveWorkspacePrefix && hasIncompatibilityWithLocalPackageVersion && (versions = [...versions, ...localPackageVersions]);
+    const uniqueVersions = [...new Set(versions)],
+      uniqueVersionsWithInfo = versionsObjectsWithSortedPackages(uniqueVersions, versionObjectsForDep);
+    return {
+      dependency,
+      versions: uniqueVersionsWithInfo
+    };
+  });
+}
+function versionsObjectsWithSortedPackages(versions, versionObjects) {
+  return versions.map(version => {
+    const matchingVersionObjects = versionObjects.filter(versionObject => versionObject.version === version);
+    return {
+      version,
+      packages: matchingVersionObjects.map(object => object.package).sort((a, b) => Package.comparator(a, b))
+    };
+  });
+}
+const HARDCODED_IGNORED_DEPENDENCIES = /* @__PURE__ */new Set(["//"
+// May be used to add comments to package.json files.
+]);
+function filterOutIgnoredDependencies(mismatchingVersions, ignoredDependencies, includedDependencyPatterns) {
+  for (const ignoreDependency of ignoredDependencies) if (!mismatchingVersions.some(mismatchingVersion => mismatchingVersion.dependency === ignoreDependency)) throw new Error(`Specified option '--ignore-dep ${ignoreDependency}', but no version mismatches detected for this dependency.`);
+  return ignoredDependencies.length > 0 || includedDependencyPatterns.length > 0 || mismatchingVersions.some(mismatchingVersion => HARDCODED_IGNORED_DEPENDENCIES.has(mismatchingVersion.dependency)) ? mismatchingVersions.filter(mismatchingVersion => !ignoredDependencies.includes(mismatchingVersion.dependency) && includedDependencyPatterns.some(ignoreDependencyPattern => mismatchingVersion.dependency.match(ignoreDependencyPattern)) && !HARDCODED_IGNORED_DEPENDENCIES.has(mismatchingVersion.dependency)) : mismatchingVersions;
+}
+function getPackages(root, ignorePackages, ignorePackagePatterns, ignorePaths, ignorePathPatterns) {
+  if (!Package.exists(root)) throw new Error("No package.json found at provided path.");
+  const packages = accumulatePackages(root, ["."]);
+  for (const ignoredPackage of ignorePackages) if (!Package.some(packages, package_ => package_.name === ignoredPackage)) throw new Error(`Specified option '--ignore-package ${ignoredPackage}', but no such package detected in workspace.`);
+  for (const ignoredPackagePattern of ignorePackagePatterns) if (
+  // eslint-disable-next-line unicorn/no-array-method-this-argument,unicorn/no-array-callback-reference -- false positive
+  !Package.some(packages, package_ => ignoredPackagePattern.test(package_.name))) throw new Error(`Specified option '--ignore-package-pattern ${String(ignoredPackagePattern)}', but no matching packages detected in workspace.`);
+  for (const ignoredPath of ignorePaths) if (
+  // eslint-disable-next-line unicorn/no-array-method-this-argument,unicorn/no-array-callback-reference -- false positive
+  !Package.some(packages, package_ => package_.pathRelative.includes(ignoredPath))) throw new Error(`Specified option '--ignore-path ${ignoredPath}', but no matching paths detected in workspace.`);
+  for (const ignoredPathPattern of ignorePathPatterns) if (
+  // eslint-disable-next-line unicorn/no-array-method-this-argument,unicorn/no-array-callback-reference -- false positive
+  !Package.some(packages, package_ => ignoredPathPattern.test(package_.pathRelative))) throw new Error(`Specified option '--ignore-path-pattern ${String(ignoredPathPattern)}', but no matching paths detected in workspace.`);
+  return ignorePackages.length > 0 || ignorePackagePatterns.length > 0 || ignorePaths.length > 0 || ignorePathPatterns.length > 0 ? packages.filter(package_ => !ignorePackages.includes(package_.name) && !ignorePackagePatterns.some(ignorePackagePattern => package_.name.match(ignorePackagePattern)) && !ignorePaths.some(ignorePath => package_.pathRelative.includes(ignorePath)) && !ignorePathPatterns.some(ignorePathPattern => package_.pathRelative.match(ignorePathPattern))) : packages;
+}
+function expandWorkspaces(root, workspacePatterns) {
+  return workspacePatterns.flatMap(workspace => workspace.includes("*") ? (0, import_fast_glob.globSync)(workspace, {
+    onlyDirectories: !0,
+    cwd: root,
+    ignore: ["**/node_modules"]
+  }) : [workspace]);
+}
+function accumulatePackages(root, paths) {
+  const results = [];
+  for (const relativePath of paths) {
+    const path = (0, import_node_path.join)(root, relativePath);
+    if (Package.exists(path)) {
+      const package_ = new Package(path, root);
+      results.push(
+      // Add the current package.
+      package_, ...accumulatePackages(path, expandWorkspaces(path, package_.workspacePatterns)));
+    }
+  }
+  return results;
+}
+class Package {
+  /** Absolute path to package */
+  path;
+  /** Absolute path to workspace.*/
+  pathWorkspace;
+  /** Absolute path to package.json. */
+  pathPackageJson;
+  packageJson;
+  packageJsonEndsInNewline;
+  pnpmWorkspacePackages;
+  constructor(path, pathWorkspace) {
+    this.path = path, this.pathWorkspace = pathWorkspace, this.pathPackageJson = (0, import_node_path.join)(path, "package.json");
+    const packageJsonContents = (0, import_node_fs.readFileSync)(this.pathPackageJson, "utf8");
+    this.packageJsonEndsInNewline = packageJsonContents.endsWith(`
+`), this.packageJson = JSON.parse(packageJsonContents);
+    const pnpmWorkspacePath = (0, import_node_path.join)(path, "pnpm-workspace.yaml");
+    if ((0, import_node_fs.existsSync)(pnpmWorkspacePath)) {
+      const pnpmWorkspaceContents = (0, import_node_fs.readFileSync)(pnpmWorkspacePath, "utf8"),
+        pnpmWorkspaceYaml = (0, import_js_yaml.load)(pnpmWorkspaceContents);
+      this.pnpmWorkspacePackages = pnpmWorkspaceYaml.packages;
+    }
+  }
+  get name() {
+    if (this.workspacePatterns.length > 0 && !this.packageJson.name) return "(Root)";
+    if (!this.packageJson.name) throw new Error(`${this.pathPackageJson} missing \`name\``);
+    return this.packageJson.name;
+  }
+  /** Relative to workspace root. */
+  get pathRelative() {
+    return (0, import_node_path.relative)(this.pathWorkspace, this.path);
+  }
+  get workspacePatterns() {
+    if (this.packageJson.workspaces) {
+      if (Array.isArray(this.packageJson.workspaces)) return this.packageJson.workspaces;
+      if (this.packageJson.workspaces.packages) {
+        if (!Array.isArray(this.packageJson.workspaces.packages)) throw new TypeError("package.json `workspaces.packages` is not a string array.");
+        return this.packageJson.workspaces.packages;
+      } else throw new TypeError("package.json `workspaces` is not a string array.");
+    }
+    if (this.pnpmWorkspacePackages) {
+      if (!Array.isArray(this.pnpmWorkspacePackages)) throw new TypeError("pnpm-workspace.yaml `packages` is not a string array.");
+      return this.pnpmWorkspacePackages;
+    }
+    return [];
+  }
+  static exists(path) {
+    const packageJsonPath = (0, import_node_path.join)(path, "package.json");
+    return (0, import_node_fs.existsSync)(packageJsonPath);
+  }
+  static some(packages, callback) {
+    return packages.some(package_ => callback(package_));
+  }
+  static comparator(package1, package2) {
+    return package1.name.localeCompare(package2.name);
+  }
+}
+var DEPENDENCY_TYPE = /* @__PURE__ */(DEPENDENCY_TYPE2 => (DEPENDENCY_TYPE2.dependencies = "dependencies", DEPENDENCY_TYPE2.devDependencies = "devDependencies", DEPENDENCY_TYPE2.optionalDependencies = "optionalDependencies", DEPENDENCY_TYPE2.peerDependencies = "peerDependencies", DEPENDENCY_TYPE2.resolutions = "resolutions", DEPENDENCY_TYPE2))(DEPENDENCY_TYPE || {});
+const DEFAULT_DEP_TYPES = ["dependencies" /* dependencies */, "devDependencies" /* devDependencies */, "optionalDependencies" /* optionalDependencies */, "resolutions" /* resolutions */
+// peerDependencies is not included by default, see discussion in: https://github.com/bmish/check-dependency-version-consistency/issues/402
+];
+function check(path) {
+  const options = {
+    includeDepPattern: ["@hanzo/gui", "react-native-web-lite", "react-native-web-internals"]
+  };
+  if (options && options.depType && options.depType.some(dt => !Object.keys(DEPENDENCY_TYPE).includes(dt))) throw new Error(`Invalid depType provided. Choices are: ${Object.keys(DEPENDENCY_TYPE).join(", ")}.`);
+  const optionsWithDefaults = {
+      fix: !1,
+      ignoreDep: [],
+      includeDepPattern: [],
+      ignorePackage: [],
+      ignorePackagePattern: [],
+      ignorePath: [],
+      ignorePathPattern: [],
+      ...options,
+      // Fallback to default if no depType(s) provided.
+      depType: options && options.depType && options.depType.length > 0 ? options.depType : DEFAULT_DEP_TYPES
+    },
+    packages = getPackages(path, optionsWithDefaults.ignorePackage, optionsWithDefaults.ignorePackagePattern.map(s => new RegExp(s)), optionsWithDefaults.ignorePath, optionsWithDefaults.ignorePathPattern.map(s => new RegExp(s))),
+    dependencies = calculateVersionsForEachDependency(packages, optionsWithDefaults.depType.map(dt => DEPENDENCY_TYPE[dt])
+    // Convert string to enum.
+    ),
+    dependenciesAndVersions = calculateDependenciesAndVersions(dependencies),
+    dependenciesAndVersionsWithMismatches = dependenciesAndVersions.filter(({
+      versions
+    }) => versions.length > 1),
+    dependenciesAndVersionsWithoutIgnored = filterOutIgnoredDependencies(dependenciesAndVersions, optionsWithDefaults.ignoreDep, optionsWithDefaults.includeDepPattern.map(s => new RegExp(s))),
+    dependenciesAndVersionsMismatchesWithoutIgnored = filterOutIgnoredDependencies(dependenciesAndVersionsWithMismatches, optionsWithDefaults.ignoreDep, optionsWithDefaults.includeDepPattern.map(s => new RegExp(s)));
+  return {
+    // Information about all dependencies.
+    dependencies: Object.fromEntries(dependenciesAndVersionsWithoutIgnored.map(({
+      dependency,
+      versions
+    }) => [dependency, {
+      isMismatching: dependenciesAndVersionsMismatchesWithoutIgnored.some(dep => dep.dependency === dependency),
+      versions
+    }]))
+  };
+}
+class CDVC {
+  /** An object mapping each dependency in the workspace to information including the versions found of it. */
+  dependencies;
+  /**
+   * @param path - path to the workspace root
+   * @param options
+   * @param options.fix - Whether to autofix inconsistencies (using latest version present)
+   * @param options.ignoreDep - Dependency(s) to ignore mismatches for
+   * @param options.includeDepPattern - RegExp(s) of dependency names to ignore mismatches for
+   * @param options.ignorePackage - Workspace package(s) to ignore mismatches for
+   * @param options.ignorePackagePattern - RegExp(s) of package names to ignore mismatches for
+   * @param options.ignorePath - Workspace-relative path(s) of packages to ignore mismatches for
+   * @param options.ignorePathPattern - RegExp(s) of workspace-relative path of packages to ignore mismatches for
+   */
+  constructor(path) {
+    const {
+      dependencies
+    } = check(path);
+    this.dependencies = dependencies;
+  }
+  toMismatchSummary() {
+    return dependenciesToMismatchSummary(this.dependencies);
+  }
+  getDependencies() {
+    return Object.keys(this.dependencies).map(dependency => this.getDependency(dependency));
+  }
+  getDependency(name) {
+    return {
+      name,
+      isMismatching: this.dependencies[name].isMismatching,
+      versions: this.dependencies[name].versions.map(version => ({
+        version: version.version,
+        packages: version.packages.map(package_ => ({
+          pathRelative: package_.pathRelative
+        }))
+      }))
+    };
+  }
+  get hasMismatchingDependencies() {
+    return Object.values(this.dependencies).some(dep => dep.isMismatching);
+  }
+}
+function dependenciesToMismatchSummary(dependencies) {
+  const mismatchingDependencyVersions = Object.entries(dependencies).filter(([, value]) => value.isMismatching).map(([dependency, value]) => ({
+    dependency,
+    versions: value.versions
+  }));
+  if (mismatchingDependencyVersions.length === 0) return "";
+  const tables = mismatchingDependencyVersions.map(object => `${object.dependency} - ${object.versions.map(v => `${v.version}`).join(", ")}`).join("");
+  return [`Found ${mismatchingDependencyVersions.length} ${mismatchingDependencyVersions.length === 1 ? "dependency" : "dependencies"} with mismatching versions across the workspace.`, tables].join(`
+`);
+}

package/dist/checkDeps.cjs

@@ -0,0 +1,200 @@
+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 checkDeps_exports = {};
+__export(checkDeps_exports, {
+  DEPENDENCY_TYPE: () => DEPENDENCY_TYPE,
+  checkDeps: () => checkDeps
+});
+module.exports = __toCommonJS(checkDeps_exports);
+var import_node_fs = require("node:fs"),
+  import_node_path = require("node:path"),
+  import_check_dep_versions = require("./check-dep-versions.cjs"),
+  DEPENDENCY_TYPE = /* @__PURE__ */(DEPENDENCY_TYPE2 => (DEPENDENCY_TYPE2.dependencies = "dependencies", DEPENDENCY_TYPE2.devDependencies = "devDependencies", DEPENDENCY_TYPE2.optionalDependencies = "optionalDependencies", DEPENDENCY_TYPE2.peerDependencies = "peerDependencies", DEPENDENCY_TYPE2.resolutions = "resolutions", DEPENDENCY_TYPE2))(DEPENDENCY_TYPE || {});
+const CRITICAL_PACKAGES = ["@hanzogui/web", "@hanzogui/core", "@hanzo/gui"];
+function checkDuplicateInstalls(root) {
+  const nodeModules = (0, import_node_path.join)(root, "node_modules");
+  if (!(0, import_node_fs.existsSync)(nodeModules)) return "";
+  const duplicates = /* @__PURE__ */new Map();
+  for (const pkg of CRITICAL_PACKAGES) {
+    const locations = findAllInstances(nodeModules, pkg);
+    if (locations.length > 1) {
+      const realPaths = /* @__PURE__ */new Set(),
+        distinctLocations = [];
+      for (const loc of locations) try {
+        const real = (0, import_node_fs.realpathSync)(loc);
+        realPaths.has(real) || (realPaths.add(real), distinctLocations.push((0, import_node_path.relative)(root, loc)));
+      } catch {
+        distinctLocations.push((0, import_node_path.relative)(root, loc));
+      }
+      distinctLocations.length > 1 && duplicates.set(pkg, distinctLocations);
+    }
+  }
+  if (duplicates.size === 0) return "";
+  const lines = ["Found duplicate gui installations in node_modules:", "", "This causes multiple runtime instances, which breaks theme/config detection.", ""];
+  for (const [pkg, locations] of duplicates) {
+    lines.push(`  ${pkg}:`);
+    for (const loc of locations) {
+      const pkgJsonPath = (0, import_node_path.join)(root, loc, "package.json");
+      let version = "?";
+      try {
+        version = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf8")).version;
+      } catch {}
+      lines.push(`    ${version} at ${loc}`);
+    }
+    lines.push("");
+  }
+  return lines.push("Fix: run your package manager's dedupe command:"), lines.push("  bun install  (bun auto-dedupes)"), lines.push("  npx yarn-deduplicate && yarn install"), lines.push("  npm dedupe"), lines.push(""), lines.push("If that doesn't help, delete node_modules and lockfile, then reinstall."), lines.join(`
+`);
+}
+function findAllInstances(nodeModulesDir, packageName, found = [], depth = 0) {
+  if (depth > 4 || !(0, import_node_fs.existsSync)(nodeModulesDir)) return found;
+  const pkgDir = (0, import_node_path.join)(nodeModulesDir, ...packageName.split("/"));
+  (0, import_node_fs.existsSync)((0, import_node_path.join)(pkgDir, "package.json")) && found.push(pkgDir);
+  try {
+    const entries = (0, import_node_fs.readdirSync)(nodeModulesDir);
+    for (const entry of entries) if (!entry.startsWith(".")) if (entry.startsWith("@")) {
+      const scopeDir = (0, import_node_path.join)(nodeModulesDir, entry);
+      try {
+        const scopeEntries = (0, import_node_fs.readdirSync)(scopeDir);
+        for (const scopeEntry of scopeEntries) {
+          const nested = (0, import_node_path.join)(scopeDir, scopeEntry, "node_modules");
+          (0, import_node_fs.existsSync)(nested) && findAllInstances(nested, packageName, found, depth + 1);
+        }
+      } catch {}
+    } else {
+      const nested = (0, import_node_path.join)(nodeModulesDir, entry, "node_modules");
+      (0, import_node_fs.existsSync)(nested) && findAllInstances(nested, packageName, found, depth + 1);
+    }
+  } catch {}
+  return found;
+}
+function checkLockfileDuplicates(root) {
+  const bunLock = (0, import_node_path.join)(root, "bun.lock"),
+    yarnLock = (0, import_node_path.join)(root, "yarn.lock"),
+    npmLock = (0, import_node_path.join)(root, "package-lock.json");
+  return (0, import_node_fs.existsSync)(bunLock) ? checkBunLockDuplicates(bunLock) : (0, import_node_fs.existsSync)(yarnLock) ? checkYarnLockDuplicates(yarnLock) : (0, import_node_fs.existsSync)(npmLock) ? checkNpmLockDuplicates(npmLock) : "";
+}
+function checkBunLockDuplicates(lockPath) {
+  try {
+    const content = (0, import_node_fs.readFileSync)(lockPath, "utf8"),
+      duplicates = /* @__PURE__ */new Map(),
+      criticalSet = new Set(CRITICAL_PACKAGES),
+      packagePattern = /["'](@gui\/[\w-]+|gui)@([^"'\s,]+)["']/g;
+    let match;
+    for (; (match = packagePattern.exec(content)) !== null;) {
+      const name = match[1],
+        version = match[2];
+      version.startsWith("workspace:") || criticalSet.has(name) && (duplicates.has(name) || duplicates.set(name, /* @__PURE__ */new Set()), duplicates.get(name).add(version));
+    }
+    return formatLockfileDuplicates(duplicates, "bun.lock");
+  } catch {
+    return "";
+  }
+}
+function checkYarnLockDuplicates(lockPath) {
+  try {
+    const content = (0, import_node_fs.readFileSync)(lockPath, "utf8"),
+      duplicates = /* @__PURE__ */new Map(),
+      criticalSet = new Set(CRITICAL_PACKAGES),
+      entryPattern = /^"?(@gui\/[\w-]+|gui)@[^":\n]+[":]?\s*$/gm,
+      versionPattern = /^\s+version\s+"([^"]+)"/gm;
+    let entryMatch;
+    for (; (entryMatch = entryPattern.exec(content)) !== null;) {
+      const name = entryMatch[1];
+      if (!criticalSet.has(name)) continue;
+      versionPattern.lastIndex = entryMatch.index;
+      const verMatch = versionPattern.exec(content);
+      verMatch && (duplicates.has(name) || duplicates.set(name, /* @__PURE__ */new Set()), duplicates.get(name).add(verMatch[1]));
+    }
+    return formatLockfileDuplicates(duplicates, "yarn.lock");
+  } catch {
+    return "";
+  }
+}
+function checkNpmLockDuplicates(lockPath) {
+  try {
+    const lock = JSON.parse((0, import_node_fs.readFileSync)(lockPath, "utf8")),
+      duplicates = /* @__PURE__ */new Map(),
+      criticalSet = new Set(CRITICAL_PACKAGES),
+      packages = lock.packages || {};
+    for (const [path, info] of Object.entries(packages)) {
+      if (!path) continue;
+      const name = info.name || path.split("node_modules/").pop();
+      if (!name || !criticalSet.has(name)) continue;
+      const version = info.version;
+      version && (duplicates.has(name) || duplicates.set(name, /* @__PURE__ */new Set()), duplicates.get(name).add(version));
+    }
+    return formatLockfileDuplicates(duplicates, "package-lock.json");
+  } catch {
+    return "";
+  }
+}
+function formatLockfileDuplicates(duplicates, lockfileName) {
+  const multiVersion = /* @__PURE__ */new Map();
+  for (const [name, versions] of duplicates) versions.size > 1 && multiVersion.set(name, [...versions].sort());
+  if (multiVersion.size === 0) return "";
+  const lines = [`Found multiple resolved versions in ${lockfileName}:`, ""];
+  for (const [name, versions] of multiVersion) lines.push(`  ${name}: ${versions.join(", ")}`);
+  return lines.push(""), lines.push("Multiple versions cause duplicate runtime instances, breaking config/theme detection."), lines.push("Fix: ensure all hanzo-gui packages use the same version range, then dedupe."), lines.join(`
+`);
+}
+function checkConfigExists(root) {
+  const configNames = ["gui.config.ts", "gui.config.tsx", "gui.config.js", "gui.config.mjs", "gui.config.cjs"],
+    searchDirs = [root, (0, import_node_path.join)(root, "src"), (0, import_node_path.join)(root, "app"), (0, import_node_path.join)(root, "config")];
+  for (const dir of searchDirs) for (const name of configNames) if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, name))) return "";
+  const buildConfigNames = ["gui.build.ts", "gui.build.js", "gui.build.mjs", "gui.build.cjs"];
+  for (const name of buildConfigNames) {
+    const buildPath = (0, import_node_path.join)(root, name);
+    if ((0, import_node_fs.existsSync)(buildPath)) try {
+      const match = (0, import_node_fs.readFileSync)(buildPath, "utf8").match(/config\s*:\s*['"`]([^'"`]+)['"`]/);
+      if (match) {
+        const configPath = (0, import_node_path.join)(root, match[1]);
+        if ((0, import_node_fs.existsSync)(configPath)) return "";
+      }
+    } catch {}
+  }
+  const pkgJsonPath = (0, import_node_path.join)(root, "package.json");
+  if ((0, import_node_fs.existsSync)(pkgJsonPath)) try {
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf8"));
+    if (pkg.gui?.config) {
+      const configPath = (0, import_node_path.join)(root, pkg.gui.config);
+      if ((0, import_node_fs.existsSync)(configPath)) return "";
+    }
+  } catch {}
+  if ((0, import_node_fs.existsSync)(pkgJsonPath)) try {
+    if (JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf8")).workspaces) return "";
+  } catch {}
+  return ["No gui.config file found.", "", "Gui requires a config file (e.g. gui.config.ts) that calls createGui().", `Without it, components will throw "Can't find Hanzo GUI configuration" at runtime.`, "", "See: https://gui.hanzo.ai/docs/core/configuration"].join(`
+`);
+}
+async function checkDeps(root) {
+  const issues = [],
+    workspaceMismatchSummary = new import_check_dep_versions.CDVC(root).toMismatchSummary();
+  workspaceMismatchSummary && issues.push(workspaceMismatchSummary);
+  const lockfileSummary = checkLockfileDuplicates(root);
+  lockfileSummary && issues.push(lockfileSummary);
+  const duplicatesSummary = checkDuplicateInstalls(root);
+  duplicatesSummary && issues.push(duplicatesSummary);
+  const configSummary = checkConfigExists(root);
+  configSummary && issues.push(configSummary), issues.length === 0 && (console.info("Gui dependencies look good \u2705"), process.exit(0));
+  for (let i = 0; i < issues.length; i++) i > 0 && console.error(""), console.error(issues[i]);
+  process.exit(1);
+}

package/dist/constants.cjs

@@ -0,0 +1,49 @@
+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 __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 __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)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  CSS_FILE_NAME: () => CSS_FILE_NAME,
+  FAILED_EVAL: () => FAILED_EVAL,
+  MEDIA_SEP: () => MEDIA_SEP,
+  SHOULD_DEBUG: () => SHOULD_DEBUG,
+  cacheDir: () => cacheDir
+});
+module.exports = __toCommonJS(constants_exports);
+var import_find_cache_dir = __toESM(require("find-cache-dir"));
+const CSS_FILE_NAME = "__snack.css",
+  MEDIA_SEP = "_",
+  cacheDir = (0, import_find_cache_dir.default)({
+    name: "hanzo-gui",
+    create: !0
+  }),
+  FAILED_EVAL = /* @__PURE__ */Symbol("failed_style_eval"),
+  SHOULD_DEBUG = process.env.DEBUG === "*" || process.env.DEBUG?.startsWith("@hanzo/gui");

package/dist/exports.cjs

@@ -0,0 +1,44 @@
+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 exports_exports = {};
+__export(exports_exports, {
+  clearFormatCache: () => import_detectModuleFormat.clearFormatCache,
+  createExtractor: () => import_createExtractor.createExtractor,
+  detectModuleFormat: () => import_detectModuleFormat.detectModuleFormat,
+  literalToAst: () => import_literalToAst.literalToAst
+});
+module.exports = __toCommonJS(exports_exports);
+__reExport(exports_exports, require("./checkDeps.cjs"), module.exports);
+__reExport(exports_exports, require("./types.cjs"), module.exports);
+var import_createExtractor = require("./extractor/createExtractor.cjs"),
+  import_literalToAst = require("./extractor/literalToAst.cjs");
+__reExport(exports_exports, require("./constants.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/extractToClassNames.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/concatClassName.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/extractToNative.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/extractHelpers.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/loadGui.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/watchGuiConfig.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/createLogger.cjs"), module.exports);
+__reExport(exports_exports, require("./registerRequire.cjs"), module.exports);
+var import_detectModuleFormat = require("./extractor/detectModuleFormat.cjs");
+__reExport(exports_exports, require("./getPragmaOptions.cjs"), module.exports);

package/dist/extractor/accessSafe.cjs

@@ -0,0 +1,46 @@
+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 __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 __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)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var accessSafe_exports = {};
+__export(accessSafe_exports, {
+  accessSafe: () => accessSafe
+});
+module.exports = __toCommonJS(accessSafe_exports);
+var t = __toESM(require("@babel/types"));
+function accessSafe(obj, member) {
+  return t.logicalExpression("&&", t.logicalExpression("&&",
+  // typeof obj === 'object
+  t.binaryExpression("===", t.unaryExpression("typeof", obj), t.stringLiteral("object")),
+  // obj !== null
+  t.binaryExpression("!==", obj, t.nullLiteral())),
+  // obj.member
+  t.memberExpression(obj, t.identifier(member), !1));
+}