@bamboocss/config 1.11.1

package/dist/index.mjs

@@ -0,0 +1,630 @@
+import {
+  diffConfigs
+} from "./chunk-6TQW6KOI.mjs";
+import {
+  SEP,
+  formatPath,
+  getReferences,
+  isTokenReference,
+  isValidToken,
+  mergeConfigs,
+  mergeHooks,
+  serializeTokenValue
+} from "./chunk-RIBK22OM.mjs";
+import {
+  resolveTsPathPattern
+} from "./chunk-RPIVZP2I.mjs";
+
+// src/bundle-config.ts
+import { logger } from "@bamboocss/logger";
+import { BambooError as BambooError2 } from "@bamboocss/shared";
+import { bundleNRequire } from "bundle-n-require";
+
+// src/find-config.ts
+import { BambooError } from "@bamboocss/shared";
+import findUp from "escalade/sync";
+import { resolve } from "path";
+
+// src/is-bamboo-config.ts
+var configName = "bamboo";
+var bambooConfigFiles = /* @__PURE__ */ new Set([
+  `${configName}.config.ts`,
+  `${configName}.config.js`,
+  `${configName}.config.mts`,
+  `${configName}.config.mjs`,
+  `${configName}.config.cts`,
+  `${configName}.config.cjs`
+]);
+var isBambooConfig = (file) => bambooConfigFiles.has(file);
+
+// src/find-config.ts
+function findConfig(options) {
+  const { cwd = process.cwd(), file } = options;
+  if (file) {
+    return resolve(cwd, file);
+  }
+  const configPath = findUp(cwd, (_dir, paths) => paths.find(isBambooConfig));
+  if (!configPath) {
+    throw new BambooError(
+      "CONFIG_NOT_FOUND",
+      `Cannot find config file \`bamboo.config.{ts,js,mjs,mts}\`. Did you forget to run \`bamboo init\`?`
+    );
+  }
+  return configPath;
+}
+
+// src/bundle-config.ts
+async function bundle(filepath, cwd) {
+  const { mod, dependencies } = await bundleNRequire(filepath, {
+    cwd,
+    interopDefault: true
+  });
+  const config = mod?.default ?? mod;
+  return {
+    config,
+    dependencies
+  };
+}
+async function bundleConfig(options) {
+  const { cwd, file } = options;
+  const filePath = findConfig({ cwd, file });
+  logger.debug("config:path", filePath);
+  const result = await bundle(filePath, cwd);
+  if (typeof result.config !== "object") {
+    throw new BambooError2("CONFIG_ERROR", `\u{1F4A5} Config must export or return an object.`);
+  }
+  result.config.outdir ??= "styled-system";
+  result.config.validation ??= "warn";
+  return {
+    ...result,
+    config: result.config,
+    path: filePath
+  };
+}
+
+// src/get-mod-deps.ts
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+// src/ts-config-paths.ts
+import { resolve as resolve2 } from "path";
+function convertTsPathsToRegexes(paths, baseUrl) {
+  const sortedPatterns = Object.keys(paths).sort((a, b) => getPrefixLength(b) - getPrefixLength(a));
+  const resolved = [];
+  for (let pattern of sortedPatterns) {
+    const relativePaths = paths[pattern];
+    pattern = escapeStringRegexp(pattern).replace(/\*/g, "(.+)");
+    resolved.push({
+      pattern: new RegExp("^" + pattern + "$"),
+      paths: relativePaths.map((relativePath) => resolve2(baseUrl, relativePath))
+    });
+  }
+  return resolved;
+}
+function getPrefixLength(pattern) {
+  const prefixLength = pattern.indexOf("*");
+  return pattern.substr(0, prefixLength).length;
+}
+function escapeStringRegexp(string) {
+  return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+
+// src/get-mod-deps.ts
+var jsExtensions = [".js", ".cjs", ".mjs"];
+var jsResolutionOrder = ["", ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts", ".jsx", ".tsx"];
+var tsResolutionOrder = ["", ".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"];
+function resolveWithExtension(file, extensions) {
+  for (const ext of extensions) {
+    const full = `${file}${ext}`;
+    if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+      return full;
+    }
+  }
+  for (const ext of extensions) {
+    const full = `${file}/index${ext}`;
+    if (fs.existsSync(full)) {
+      return full;
+    }
+  }
+  return null;
+}
+var importRegex = /import[\s\S]*?['"](.{3,}?)['"]/gi;
+var importFromRegex = /import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
+var requireRegex = /require\(['"`](.+)['"`]\)/gi;
+var exportRegex = /export[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
+function getDeps(opts, fromAlias) {
+  const { filename, seen } = opts;
+  const { moduleResolution: _, ...compilerOptions } = opts.compilerOptions ?? {};
+  const absoluteFile = resolveWithExtension(
+    path.resolve(opts.cwd, filename),
+    jsExtensions.includes(opts.ext) ? jsResolutionOrder : tsResolutionOrder
+  );
+  if (absoluteFile === null) return;
+  if (fromAlias) {
+    opts.foundModuleAliases.set(fromAlias, absoluteFile);
+  }
+  if (seen.size > 1 && seen.has(absoluteFile)) return;
+  seen.add(absoluteFile);
+  const contents = fs.readFileSync(absoluteFile, "utf-8");
+  const fileDeps = [
+    ...contents.matchAll(importRegex),
+    ...contents.matchAll(importFromRegex),
+    ...contents.matchAll(requireRegex),
+    ...contents.matchAll(exportRegex)
+  ];
+  if (!fileDeps.length) return;
+  const nextOpts = {
+    // Resolve new base for new imports/requires
+    cwd: path.dirname(absoluteFile),
+    ext: path.extname(absoluteFile),
+    seen,
+    baseUrl: opts.baseUrl,
+    pathMappings: opts.pathMappings,
+    foundModuleAliases: opts.foundModuleAliases
+  };
+  fileDeps.forEach((match) => {
+    const mod = match[1];
+    if (mod[0] === ".") {
+      getDeps(Object.assign({}, nextOpts, { filename: mod }));
+      return;
+    }
+    try {
+      const found = ts.resolveModuleName(mod, absoluteFile, compilerOptions, ts.sys).resolvedModule;
+      if (found && found.extension.endsWith("ts")) {
+        getDeps(Object.assign({}, nextOpts, { filename: found.resolvedFileName }));
+        return;
+      }
+      if (!opts.pathMappings) return;
+      const filename2 = resolveTsPathPattern(opts.pathMappings, mod);
+      if (!filename2) return;
+      getDeps(Object.assign({}, nextOpts, { filename: filename2 }), mod);
+    } catch {
+    }
+  });
+}
+function getConfigDependencies(filePath, tsOptions = { pathMappings: [] }, compilerOptions) {
+  if (filePath === null) return { deps: /* @__PURE__ */ new Set(), aliases: /* @__PURE__ */ new Map() };
+  const foundModuleAliases = /* @__PURE__ */ new Map();
+  const deps = /* @__PURE__ */ new Set();
+  deps.add(filePath);
+  getDeps({
+    filename: filePath,
+    ext: path.extname(filePath),
+    cwd: path.dirname(filePath),
+    seen: deps,
+    baseUrl: tsOptions.baseUrl,
+    pathMappings: tsOptions.pathMappings ?? [],
+    foundModuleAliases,
+    compilerOptions
+  });
+  return { deps, aliases: foundModuleAliases };
+}
+
+// src/get-resolved-config.ts
+import { omit, pick, traverse } from "@bamboocss/shared";
+var hookUtils = {
+  omit,
+  pick,
+  traverse
+};
+async function getResolvedConfig(config, cwd, hooks) {
+  const stack = [config];
+  const configs = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const subPresets = current.presets ?? [];
+    for (const subPreset of subPresets) {
+      let presetConfig;
+      let presetName;
+      if (typeof subPreset === "string") {
+        const presetModule = await bundle(subPreset, cwd);
+        presetConfig = presetModule.config;
+        presetName = subPreset;
+      } else {
+        presetConfig = await subPreset;
+        presetName = presetConfig.name || "unknown-preset";
+      }
+      if (hooks?.["preset:resolved"]) {
+        const resolvedPreset = await hooks["preset:resolved"]({
+          preset: presetConfig,
+          name: presetName,
+          utils: hookUtils
+        });
+        if (resolvedPreset !== void 0) {
+          presetConfig = resolvedPreset;
+        }
+      }
+      stack.push(presetConfig);
+    }
+    configs.unshift(current);
+  }
+  const merged = mergeConfigs(configs);
+  merged.presets = configs.slice(0, -1);
+  return merged;
+}
+
+// src/resolve-config.ts
+import { logger as logger3 } from "@bamboocss/logger";
+import { BAMBOO_CONFIG_NAME, omit as omit2, parseJson, pick as pick2, stringifyJson, traverse as traverse2 } from "@bamboocss/shared";
+
+// src/bundled-preset.ts
+import { preset as presetBase } from "@bamboocss/preset-base";
+import { preset as presetBamboo } from "@bamboocss/preset-bamboo";
+var bundledPresets = {
+  "@bamboocss/preset-base": presetBase,
+  "@bamboocss/preset-bamboo": presetBamboo,
+  "@bamboocss/dev/presets": presetBamboo
+};
+var bundledPresetsNames = Object.keys(bundledPresets);
+var isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
+var getBundledPreset = (preset) => {
+  return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
+};
+
+// src/validate-config.ts
+import { logger as logger2 } from "@bamboocss/logger";
+import { BambooError as BambooError3 } from "@bamboocss/shared";
+
+// src/validation/validate-artifact.ts
+var validateArtifactNames = (names, addError) => {
+  names.recipes.forEach((recipeName) => {
+    if (names.slotRecipes.has(recipeName)) {
+      addError("recipes", `This recipe name is already used in \`theme.slotRecipes\`: ${recipeName}`);
+    }
+    if (names.patterns.has(recipeName)) {
+      addError("recipes", `This recipe name is already used in \`patterns\`: \`${recipeName}\``);
+    }
+  });
+  names.slotRecipes.forEach((recipeName) => {
+    if (names.patterns.has(recipeName)) {
+      addError("recipes", `This recipe name is already used in \`patterns\`: ${recipeName}`);
+    }
+  });
+};
+
+// src/validation/validate-breakpoints.ts
+import { getUnit } from "@bamboocss/shared";
+var validateBreakpoints = (breakpoints, addError) => {
+  if (!breakpoints) return;
+  const units = /* @__PURE__ */ new Set();
+  const values = Object.values(breakpoints);
+  for (const value of values) {
+    const unit = getUnit(value) ?? "px";
+    units.add(unit);
+  }
+  if (units.size > 1) {
+    addError("breakpoints", `All breakpoints must use the same unit: \`${values.join(", ")}\``);
+  }
+};
+
+// src/validation/validate-condition.ts
+import { isString } from "@bamboocss/shared";
+var validateObjectCondition = (obj, addError) => {
+  let hasSlot = false;
+  for (const [key, value] of Object.entries(obj)) {
+    if (!key.startsWith("@") && !key.includes("&")) {
+      addError("conditions", `Selectors should contain the \`&\` character: \`${key}\``);
+    }
+    if (value === "@slot") {
+      hasSlot = true;
+      continue;
+    }
+    if (typeof value === "string") {
+      addError(
+        "conditions",
+        `Object condition leaves must be the literal string \`'@slot'\`, got \`${JSON.stringify(value)}\` at \`${key}\``
+      );
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      const nested = validateObjectCondition(value, addError);
+      if (nested.hasSlot) hasSlot = true;
+    }
+  }
+  return { hasSlot };
+};
+var validateConditions = (conditions, addError) => {
+  if (!conditions) return;
+  Object.values(conditions).forEach((condition) => {
+    if (isString(condition)) {
+      if (!condition.startsWith("@") && !condition.includes("&")) {
+        addError("conditions", `Selectors should contain the \`&\` character: \`${condition}\``);
+      }
+      return;
+    }
+    if (Array.isArray(condition)) {
+      condition.forEach((c) => {
+        if (!c.startsWith("@") && !c.includes("&")) {
+          addError("conditions", `Selectors should contain the \`&\` character: \`${c}\``);
+        }
+      });
+      return;
+    }
+    const { hasSlot } = validateObjectCondition(condition, addError);
+    if (!hasSlot) {
+      addError("conditions", `Object conditions must contain at least one \`'@slot'\` marker`);
+    }
+  });
+};
+
+// src/validation/validate-patterns.ts
+var validatePatterns = (patterns, names) => {
+  if (!patterns) return;
+  Object.keys(patterns).forEach((patternName) => {
+    names.patterns.add(patternName);
+  });
+};
+
+// src/validation/validate-recipes.ts
+var validateRecipes = (options) => {
+  const {
+    config: { theme },
+    artifacts
+  } = options;
+  if (!theme) return;
+  if (theme.recipes) {
+    Object.keys(theme.recipes).forEach((recipeName) => {
+      artifacts.recipes.add(recipeName);
+    });
+  }
+  if (theme.slotRecipes) {
+    Object.keys(theme.slotRecipes).forEach((recipeName) => {
+      artifacts.slotRecipes.add(recipeName);
+    });
+  }
+  return artifacts;
+};
+
+// src/validation/validate-tokens.ts
+import { isObject, walkObject } from "@bamboocss/shared";
+
+// src/validation/validate-token-references.ts
+var validateTokenReferences = (props) => {
+  const { valueAtPath, refsByPath, addError, typeByPath } = props;
+  refsByPath.forEach((refs, path2) => {
+    if (refs.has(path2)) {
+      addError("tokens", `Self token reference: \`${path2}\``);
+    }
+    const stack = [path2];
+    while (stack.length > 0) {
+      let currentPath = stack.pop();
+      if (currentPath.includes("/")) {
+        const [tokenPath] = currentPath.split("/");
+        currentPath = tokenPath;
+      }
+      const value = valueAtPath.get(currentPath);
+      if (!value) {
+        const configKey = typeByPath.get(path2);
+        addError("tokens", `Missing token: \`${currentPath}\` used in \`theme.${configKey}.${path2}\``);
+      }
+      if (isTokenReference(value) && !refsByPath.has(value)) {
+        addError("tokens", `Unknown token reference: \`${currentPath}\` used in \`${value}\``);
+      }
+      const deps = refsByPath.get(currentPath);
+      if (!deps) continue;
+      for (const transitiveDep of deps) {
+        if (path2 === transitiveDep) {
+          addError(
+            "tokens",
+            `Circular token reference: \`${transitiveDep}\` -> \`${currentPath}\` -> ... -> \`${path2}\``
+          );
+          break;
+        }
+        stack.push(transitiveDep);
+      }
+    }
+  });
+};
+
+// src/validation/validate-tokens.ts
+var validateTokens = (options) => {
+  const {
+    config: { theme },
+    tokens,
+    addError
+  } = options;
+  if (!theme) return;
+  const { tokenNames, semanticTokenNames, valueAtPath, refsByPath, typeByPath } = tokens;
+  if (theme.tokens) {
+    const tokenPaths = /* @__PURE__ */ new Set();
+    walkObject(
+      theme.tokens,
+      (value, paths) => {
+        const path2 = paths.join(SEP);
+        tokenNames.add(path2);
+        tokenPaths.add(path2);
+        valueAtPath.set(path2, value);
+        if (path2.includes("DEFAULT")) {
+          valueAtPath.set(path2.replace(SEP + "DEFAULT", ""), value);
+        }
+      },
+      {
+        stop: isValidToken
+      }
+    );
+    tokenPaths.forEach((path2) => {
+      const itemValue = valueAtPath.get(path2);
+      const formattedPath = formatPath(path2);
+      typeByPath.set(formattedPath, "tokens");
+      if (!isValidToken(itemValue)) {
+        addError("tokens", `Token must contain 'value': \`theme.tokens.${formattedPath}\``);
+        return;
+      }
+      if (path2.includes(" ")) {
+        addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
+        return;
+      }
+      const valueStr = serializeTokenValue(itemValue.value || itemValue);
+      if (isTokenReference(valueStr)) {
+        refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
+      }
+      const references = refsByPath.get(formattedPath);
+      if (!references) return;
+      getReferences(valueStr).forEach((reference) => {
+        references.add(reference);
+      });
+    });
+  }
+  if (theme.semanticTokens) {
+    const tokenPaths = /* @__PURE__ */ new Set();
+    walkObject(
+      theme.semanticTokens,
+      (value, paths) => {
+        const path2 = paths.join(SEP);
+        semanticTokenNames.add(path2);
+        valueAtPath.set(path2, value);
+        tokenPaths.add(path2);
+        if (path2.includes("DEFAULT")) {
+          valueAtPath.set(path2.replace(SEP + "DEFAULT", ""), value);
+        }
+        if (!isValidToken(value)) return;
+        walkObject(value, (itemValue, paths2) => {
+          const valuePath = paths2.join(SEP);
+          const formattedPath = formatPath(path2);
+          typeByPath.set(formattedPath, "semanticTokens");
+          const fullPath = formattedPath + "." + paths2.join(SEP);
+          if (valuePath.includes("value" + SEP + "value")) {
+            addError("tokens", `You used \`value\` twice resulting in an invalid token \`theme.tokens.${fullPath}\``);
+          }
+          const valueStr = serializeTokenValue(itemValue.value || itemValue);
+          if (isTokenReference(valueStr)) {
+            if (!refsByPath.has(formattedPath)) {
+              refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
+            }
+            const references = refsByPath.get(formattedPath);
+            if (!references) return;
+            getReferences(valueStr).forEach((reference) => {
+              references.add(reference);
+            });
+          }
+        });
+      },
+      {
+        stop: isValidToken
+      }
+    );
+    tokenPaths.forEach((path2) => {
+      const formattedPath = formatPath(path2);
+      const value = valueAtPath.get(path2);
+      if (path2.includes(" ")) {
+        addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
+        return;
+      }
+      if (!isObject(value) && !path2.includes("value")) {
+        addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
+      }
+    });
+  }
+  validateTokenReferences({ valueAtPath, refsByPath, addError, typeByPath });
+};
+
+// src/validate-config.ts
+var validateConfig = (config) => {
+  if (config.validation === "none") return;
+  const warnings = /* @__PURE__ */ new Set();
+  const addError = (scope, message) => {
+    warnings.add(`[${scope}] ` + message);
+  };
+  validateBreakpoints(config.theme?.breakpoints, addError);
+  validateConditions(config.conditions, addError);
+  const artifacts = {
+    recipes: /* @__PURE__ */ new Set(),
+    slotRecipes: /* @__PURE__ */ new Set(),
+    patterns: /* @__PURE__ */ new Set()
+  };
+  const tokens = {
+    tokenNames: /* @__PURE__ */ new Set(),
+    semanticTokenNames: /* @__PURE__ */ new Set(),
+    valueAtPath: /* @__PURE__ */ new Map(),
+    refsByPath: /* @__PURE__ */ new Map(),
+    typeByPath: /* @__PURE__ */ new Map()
+  };
+  if (config.theme) {
+    validateTokens({ config, tokens, addError });
+    validateRecipes({ config, tokens, artifacts, addError });
+  }
+  validatePatterns(config.patterns, artifacts);
+  validateArtifactNames(artifacts, addError);
+  if (warnings.size) {
+    const errors = `\u26A0\uFE0F Invalid config:
+${Array.from(warnings).map((err) => "- " + err).join("\n")}
+`;
+    if (config.validation === "error") {
+      throw new BambooError3("CONFIG_ERROR", errors);
+    }
+    logger2.warn("config", errors);
+    return warnings;
+  }
+};
+
+// src/resolve-config.ts
+var hookUtils2 = {
+  omit: omit2,
+  pick: pick2,
+  traverse: traverse2
+};
+async function resolveConfig(result, cwd) {
+  const presets = /* @__PURE__ */ new Set();
+  if (!result.config.eject) {
+    presets.add(presetBase);
+  }
+  if (result.config.presets) {
+    result.config.presets.forEach((preset) => {
+      presets.add(getBundledPreset(preset) ?? preset);
+    });
+  } else if (!result.config.eject) {
+    presets.add(presetBamboo);
+  }
+  result.config.presets = Array.from(presets);
+  const userConfig = result.config;
+  const pluginHooks = userConfig.plugins ?? [];
+  if (userConfig.hooks) {
+    pluginHooks.push({ name: BAMBOO_CONFIG_NAME, hooks: userConfig.hooks });
+  }
+  const earlyHooks = mergeHooks(pluginHooks);
+  const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
+  const hooks = mergedConfig.hooks ?? {};
+  if (mergedConfig.logLevel) {
+    logger3.level = mergedConfig.logLevel;
+  }
+  validateConfig(mergedConfig);
+  const loadConfigResult = {
+    ...result,
+    config: mergedConfig
+  };
+  if (hooks["config:resolved"]) {
+    const result2 = await hooks["config:resolved"]({
+      config: loadConfigResult.config,
+      path: loadConfigResult.path,
+      dependencies: loadConfigResult.dependencies,
+      utils: hookUtils2
+    });
+    if (result2) {
+      loadConfigResult.config = result2;
+    }
+  }
+  const serialized = stringifyJson(
+    Object.assign({}, loadConfigResult.config, { name: BAMBOO_CONFIG_NAME, presets: [] })
+  );
+  const deserialize = () => parseJson(serialized);
+  return { ...loadConfigResult, serialized, deserialize, hooks };
+}
+
+// src/load-config.ts
+async function loadConfig(options) {
+  const result = await bundleConfig(options);
+  return resolveConfig(result, options.cwd);
+}
+export {
+  bundleConfig,
+  convertTsPathsToRegexes,
+  diffConfigs,
+  findConfig,
+  getConfigDependencies,
+  getResolvedConfig,
+  loadConfig,
+  mergeConfigs,
+  mergeHooks,
+  resolveConfig
+};