@bamboocss/config 1.11.1

package/LICENSE.md

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2023 Segun Adebayo
+
+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/dist/chunk-6TQW6KOI.mjs

@@ -0,0 +1,154 @@
+// src/diff-config.ts
+import { dashCase } from "@bamboocss/shared";
+import microdiff from "microdiff";
+
+// src/create-matcher.ts
+function createMatcher(id, patterns) {
+  if (!patterns?.length) return () => void 0;
+  const includePatterns = [];
+  const excludePatterns = [];
+  const deduped = new Set(patterns);
+  deduped.forEach((pattern) => {
+    const regexString = pattern.replace(/\*/g, ".*");
+    if (pattern.startsWith("!")) {
+      excludePatterns.push(regexString.slice(1));
+    } else {
+      includePatterns.push(regexString);
+    }
+  });
+  const include = new RegExp(includePatterns.join("|"));
+  const exclude = new RegExp(excludePatterns.join("|"));
+  return (path) => {
+    if (excludePatterns.length && exclude.test(path)) return;
+    return include.test(path) ? id : void 0;
+  };
+}
+
+// src/config-deps.ts
+var all = [
+  "clean",
+  "cwd",
+  "eject",
+  "outdir",
+  "forceConsistentTypeExtension",
+  "outExtension",
+  "emitTokensOnly",
+  "presets",
+  "plugins",
+  "hooks"
+];
+var format = [
+  "syntax",
+  "hash",
+  "prefix",
+  "separator",
+  "strictTokens",
+  "strictPropertyValues",
+  "shorthands"
+];
+var tokens = [
+  "utilities",
+  "conditions",
+  "theme.tokens",
+  "theme.semanticTokens",
+  "theme.breakpoints",
+  "theme.containerNames",
+  "theme.containerSizes"
+];
+var jsx = ["jsxFramework", "jsxFactory", "jsxStyleProps", "syntax"];
+var common = tokens.concat(jsx, format);
+var artifactConfigDeps = {
+  helpers: ["syntax", "jsxFramework"],
+  keyframes: ["theme.keyframes", "layers"],
+  "design-tokens": ["layers", "!utilities.*.className"].concat(tokens),
+  types: ["!utilities.*.className"].concat(common),
+  "css-fn": common,
+  cva: ["syntax"],
+  sva: ["syntax"],
+  cx: [],
+  "create-recipe": ["separator", "prefix", "hash"],
+  "recipes-index": ["theme.recipes", "theme.slotRecipes"],
+  recipes: ["theme.recipes", "theme.slotRecipes"],
+  "patterns-index": ["syntax", "patterns"],
+  patterns: ["syntax", "patterns"],
+  "jsx-is-valid-prop": common,
+  "jsx-factory": jsx,
+  "jsx-helpers": jsx,
+  "jsx-patterns": jsx.concat("patterns"),
+  "jsx-patterns-index": jsx.concat("patterns"),
+  "jsx-create-style-context": jsx,
+  "css-index": ["syntax"],
+  "package.json": ["forceConsistentTypeExtension", "outExtension"],
+  "types-styles": ["shorthands"],
+  "types-conditions": ["conditions"],
+  "types-jsx": jsx,
+  "types-entry": [],
+  "types-gen": [],
+  "types-gen-system": [],
+  themes: ["themes"].concat(tokens),
+  // staticCss depends on tokens (for wildcards) and recipes (for recipe rules)
+  "static-css": ["staticCss", "patterns", "theme.recipes", "theme.slotRecipes"].concat(tokens),
+  // Split CSS artifacts (generated via cssgen --splitting)
+  styles: [],
+  "styles.css": []
+};
+var artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) => {
+  if (!paths.length) return () => void 0;
+  return createMatcher(key, paths.concat(all));
+});
+
+// src/diff-config.ts
+var runIfFn = (fn) => typeof fn === "function" ? fn() : fn;
+var hasRecipeStateTransition = (prevConfig, nextConfig) => {
+  const prevRecipes = prevConfig.theme?.recipes ?? {};
+  const prevSlotRecipes = prevConfig.theme?.slotRecipes ?? {};
+  const prevHasRecipes = Object.keys(prevRecipes).length > 0 || Object.keys(prevSlotRecipes).length > 0;
+  const nextRecipes = nextConfig.theme?.recipes ?? {};
+  const nextSlotRecipes = nextConfig.theme?.slotRecipes ?? {};
+  const nextHasRecipes = Object.keys(nextRecipes).length > 0 || Object.keys(nextSlotRecipes).length > 0;
+  return prevHasRecipes !== nextHasRecipes;
+};
+function diffConfigs(config, prevConfig) {
+  const affected = {
+    artifacts: /* @__PURE__ */ new Set(),
+    hasConfigChanged: false,
+    diffs: []
+  };
+  if (!prevConfig) {
+    affected.hasConfigChanged = true;
+    return affected;
+  }
+  const configDiff = microdiff(prevConfig, runIfFn(config));
+  if (!configDiff.length) {
+    return affected;
+  }
+  affected.hasConfigChanged = true;
+  affected.diffs = configDiff;
+  configDiff.forEach((change) => {
+    const changePath = change.path.join(".");
+    artifactMatchers.forEach((matcher) => {
+      const id = matcher(changePath);
+      if (!id) return;
+      if (id === "recipes") {
+        const name = dashCase(change.path.slice(1, 3).join("."));
+        affected.artifacts.add(name);
+      }
+      if (id === "patterns") {
+        const name = dashCase(change.path.slice(0, 2).join("."));
+        affected.artifacts.add(name);
+      }
+      affected.artifacts.add(id);
+    });
+  });
+  if (affected.artifacts.has("recipes") || affected.artifacts.has("recipes-index")) {
+    const nextConfig = runIfFn(config);
+    if (hasRecipeStateTransition(prevConfig, nextConfig)) {
+      affected.artifacts.add("create-recipe");
+    }
+  }
+  return affected;
+}
+
+export {
+  diffConfigs
+};

package/dist/chunk-RIBK22OM.mjs

@@ -0,0 +1,265 @@
+// src/merge-config.ts
+import { BAMBOO_CONFIG_NAME, assign, mergeWith, mergeAndConcat, walkObject } from "@bamboocss/shared";
+
+// src/merge-hooks.ts
+import { logger } from "@bamboocss/logger";
+var mergeHooks = (plugins) => {
+  const hooksFns = {};
+  plugins.forEach(({ name, hooks }) => {
+    Object.entries(hooks ?? {}).forEach(([key, value]) => {
+      if (!hooksFns[key]) {
+        hooksFns[key] = [];
+      }
+      hooksFns[key].push([name, value]);
+    });
+  });
+  const mergedHooks = Object.fromEntries(
+    Object.entries(hooksFns).map(([key, entries]) => {
+      const fns = entries.map(([name, fn]) => tryCatch(name, fn));
+      const reducer = key in reducers ? reducers[key] : void 0;
+      if (reducer) {
+        return [key, reducer(fns)];
+      }
+      return [key, syncHooks.includes(key) ? callAll(...fns) : callAllAsync(...fns)];
+    })
+  );
+  return mergedHooks;
+};
+var createReducer = (reducer) => reducer;
+var reducers = {
+  "config:resolved": createReducer((fns) => async (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.config;
+    let config = args.config;
+    for (const hookFn of fns) {
+      const result = await hookFn(Object.assign(args, { config, original }));
+      if (result !== void 0) {
+        config = result;
+      }
+    }
+    return config;
+  }),
+  "parser:before": createReducer((fns) => (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.content;
+    let content = args.content;
+    for (const hookFn of fns) {
+      const result = hookFn(Object.assign(args, { content, original }));
+      if (result !== void 0) {
+        content = result;
+      }
+    }
+    return content;
+  }),
+  "parser:preprocess": createReducer((fns) => (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.data;
+    let data = args.data;
+    for (const hookFn of fns) {
+      const result = hookFn(Object.assign(args, { data, original }));
+      if (result !== void 0) {
+        data = result;
+      }
+    }
+    return data;
+  }),
+  "cssgen:done": createReducer((fns) => (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.content;
+    let content = args.content;
+    for (const hookFn of fns) {
+      const result = hookFn(Object.assign(args, { content, original }));
+      if (result !== void 0) {
+        content = result;
+      }
+    }
+    return content;
+  }),
+  "codegen:prepare": createReducer((fns) => async (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.artifacts;
+    let artifacts = args.artifacts;
+    for (const hookFn of fns) {
+      const result = await hookFn(Object.assign(args, { artifacts, original }));
+      if (result) {
+        artifacts = result;
+      }
+    }
+    return artifacts;
+  }),
+  "preset:resolved": createReducer((fns) => async (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.preset;
+    let preset = args.preset;
+    for (const hookFn of fns) {
+      const result = await hookFn(Object.assign(args, { preset, original }));
+      if (result !== void 0) {
+        preset = result;
+      }
+    }
+    return preset;
+  }),
+  "css:optimize": createReducer((fns) => (_args) => {
+    const args = Object.assign({}, _args);
+    const original = _args.css;
+    let css = args.css;
+    for (const hookFn of fns) {
+      const result = hookFn(Object.assign(args, { css, original }));
+      if (result !== void 0) {
+        css = result;
+      }
+    }
+    return css;
+  })
+};
+var syncHooks = [
+  "context:created",
+  "parser:before",
+  "parser:preprocess",
+  "parser:after",
+  "cssgen:done",
+  "css:optimize"
+];
+var callAllAsync = (...fns) => async (...a) => {
+  for (const fn of fns) {
+    await fn?.(...a);
+  }
+};
+var callAll = (...fns) => (...a) => {
+  fns.forEach((fn) => fn?.(...a));
+};
+var tryCatch = (name, fn) => {
+  return (...args) => {
+    try {
+      return fn(...args);
+    } catch (e) {
+      logger.caughtError("hooks", `Error in plugin "${name}"`, e);
+    }
+  };
+};
+
+// src/validation/utils.ts
+import { isObject, isString } from "@bamboocss/shared";
+var REFERENCE_REGEX = /({([^}]*)})/g;
+var curlyBracketRegex = /[{}]/g;
+var isValidToken = (token) => isObject(token) && Object.hasOwnProperty.call(token, "value");
+var isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
+var formatPath = (path) => path;
+var SEP = ".";
+function getReferences(value) {
+  if (typeof value !== "string") return [];
+  const matches = value.match(REFERENCE_REGEX);
+  if (!matches) return [];
+  return matches.map((match) => match.replace(curlyBracketRegex, "")).map((value2) => {
+    return value2.trim().split("/")[0];
+  });
+}
+var serializeTokenValue = (value) => {
+  if (isString(value)) {
+    return value;
+  }
+  if (isObject(value)) {
+    return Object.values(value).map((v) => serializeTokenValue(v)).join(" ");
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => serializeTokenValue(v)).join(" ");
+  }
+  return value.toString();
+};
+
+// src/merge-config.ts
+function getExtends(items) {
+  return items.reduce((merged, { extend }) => {
+    if (!extend) return merged;
+    return mergeWith(merged, extend, (originalValue, newValue) => {
+      if (newValue === void 0) {
+        return originalValue ?? [];
+      }
+      if (originalValue === void 0) {
+        return [newValue];
+      }
+      if (Array.isArray(originalValue)) {
+        return [newValue, ...originalValue];
+      }
+      return [newValue, originalValue];
+    });
+  }, {});
+}
+function mergeRecords(records) {
+  return {
+    ...records.reduce((acc, record) => assign(acc, record), {}),
+    extend: getExtends(records)
+  };
+}
+function mergeExtensions(records) {
+  const { extend = [], ...restProps } = mergeRecords(records);
+  return mergeWith(restProps, extend, (obj, extensions) => {
+    return mergeAndConcat({}, obj, ...extensions);
+  });
+}
+var isEmptyObject = (obj) => typeof obj === "object" && Object.keys(obj).length === 0;
+var compact = (obj) => {
+  return Object.keys(obj).reduce((acc, key) => {
+    if (obj[key] !== void 0 && !isEmptyObject(obj[key])) {
+      acc[key] = obj[key];
+    }
+    return acc;
+  }, {});
+};
+var tokenKeys = ["description", "extensions", "type", "value", "deprecated"];
+function mergeConfigs(configs) {
+  const userConfig = configs.at(-1);
+  const pluginHooks = userConfig.plugins ?? [];
+  if (userConfig.hooks) {
+    pluginHooks.push({ name: BAMBOO_CONFIG_NAME, hooks: userConfig.hooks });
+  }
+  const reversed = Array.from(configs).reverse();
+  const mergedResult = assign(
+    {
+      conditions: mergeExtensions(reversed.map((config) => config.conditions ?? {})),
+      theme: mergeExtensions(reversed.map((config) => config.theme ?? {})),
+      patterns: mergeExtensions(reversed.map((config) => config.patterns ?? {})),
+      utilities: mergeExtensions(reversed.map((config) => config.utilities ?? {})),
+      globalCss: mergeExtensions(reversed.map((config) => config.globalCss ?? {})),
+      globalVars: mergeExtensions(reversed.map((config) => config.globalVars ?? {})),
+      globalFontface: mergeExtensions(reversed.map((config) => config.globalFontface ?? {})),
+      globalPositionTry: mergeExtensions(reversed.map((config) => config.globalPositionTry ?? {})),
+      staticCss: mergeExtensions(reversed.map((config) => config.staticCss ?? {})),
+      themes: mergeExtensions(reversed.map((config) => config.themes ?? {})),
+      hooks: mergeHooks(pluginHooks)
+    },
+    ...reversed
+  );
+  const withoutEmpty = compact(mergedResult);
+  if (withoutEmpty.theme?.tokens) {
+    walkObject(withoutEmpty.theme.tokens, (args) => args, {
+      stop(token) {
+        if (!isValidToken(token)) return false;
+        const keys = Object.keys(token);
+        const nestedKeys = keys.filter((k) => !tokenKeys.includes(k));
+        const nested = nestedKeys.length > 0;
+        if (nested) {
+          token.DEFAULT ||= {};
+          tokenKeys.forEach((key) => {
+            if (token[key] == null) return;
+            token.DEFAULT[key] ||= token[key];
+            delete token[key];
+          });
+        }
+        return true;
+      }
+    });
+  }
+  return withoutEmpty;
+}
+
+export {
+  mergeHooks,
+  isValidToken,
+  isTokenReference,
+  formatPath,
+  SEP,
+  getReferences,
+  serializeTokenValue,
+  mergeConfigs
+};

package/dist/chunk-RPIVZP2I.mjs

@@ -0,0 +1,22 @@
+// src/resolve-ts-path-pattern.ts
+import { posix, sep } from "path";
+var resolveTsPathPattern = (pathMappings, moduleSpecifier) => {
+  for (const mapping of pathMappings) {
+    const match = moduleSpecifier.match(mapping.pattern);
+    if (!match) {
+      continue;
+    }
+    for (const pathTemplate of mapping.paths) {
+      let starCount = 0;
+      const mappedId = pathTemplate.replace(/\*/g, () => {
+        const matchIndex = Math.min(++starCount, match.length - 1);
+        return match[matchIndex];
+      });
+      return mappedId.split(sep).join(posix.sep);
+    }
+  }
+};
+
+export {
+  resolveTsPathPattern
+};

package/dist/diff-config.js

@@ -0,0 +1,188 @@
+"use strict";
+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, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[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);
+
+// src/diff-config.ts
+var diff_config_exports = {};
+__export(diff_config_exports, {
+  diffConfigs: () => diffConfigs
+});
+module.exports = __toCommonJS(diff_config_exports);
+var import_shared = require("@bamboocss/shared");
+var import_microdiff = __toESM(require("microdiff"));
+
+// src/create-matcher.ts
+function createMatcher(id, patterns) {
+  if (!patterns?.length) return () => void 0;
+  const includePatterns = [];
+  const excludePatterns = [];
+  const deduped = new Set(patterns);
+  deduped.forEach((pattern) => {
+    const regexString = pattern.replace(/\*/g, ".*");
+    if (pattern.startsWith("!")) {
+      excludePatterns.push(regexString.slice(1));
+    } else {
+      includePatterns.push(regexString);
+    }
+  });
+  const include = new RegExp(includePatterns.join("|"));
+  const exclude = new RegExp(excludePatterns.join("|"));
+  return (path) => {
+    if (excludePatterns.length && exclude.test(path)) return;
+    return include.test(path) ? id : void 0;
+  };
+}
+
+// src/config-deps.ts
+var all = [
+  "clean",
+  "cwd",
+  "eject",
+  "outdir",
+  "forceConsistentTypeExtension",
+  "outExtension",
+  "emitTokensOnly",
+  "presets",
+  "plugins",
+  "hooks"
+];
+var format = [
+  "syntax",
+  "hash",
+  "prefix",
+  "separator",
+  "strictTokens",
+  "strictPropertyValues",
+  "shorthands"
+];
+var tokens = [
+  "utilities",
+  "conditions",
+  "theme.tokens",
+  "theme.semanticTokens",
+  "theme.breakpoints",
+  "theme.containerNames",
+  "theme.containerSizes"
+];
+var jsx = ["jsxFramework", "jsxFactory", "jsxStyleProps", "syntax"];
+var common = tokens.concat(jsx, format);
+var artifactConfigDeps = {
+  helpers: ["syntax", "jsxFramework"],
+  keyframes: ["theme.keyframes", "layers"],
+  "design-tokens": ["layers", "!utilities.*.className"].concat(tokens),
+  types: ["!utilities.*.className"].concat(common),
+  "css-fn": common,
+  cva: ["syntax"],
+  sva: ["syntax"],
+  cx: [],
+  "create-recipe": ["separator", "prefix", "hash"],
+  "recipes-index": ["theme.recipes", "theme.slotRecipes"],
+  recipes: ["theme.recipes", "theme.slotRecipes"],
+  "patterns-index": ["syntax", "patterns"],
+  patterns: ["syntax", "patterns"],
+  "jsx-is-valid-prop": common,
+  "jsx-factory": jsx,
+  "jsx-helpers": jsx,
+  "jsx-patterns": jsx.concat("patterns"),
+  "jsx-patterns-index": jsx.concat("patterns"),
+  "jsx-create-style-context": jsx,
+  "css-index": ["syntax"],
+  "package.json": ["forceConsistentTypeExtension", "outExtension"],
+  "types-styles": ["shorthands"],
+  "types-conditions": ["conditions"],
+  "types-jsx": jsx,
+  "types-entry": [],
+  "types-gen": [],
+  "types-gen-system": [],
+  themes: ["themes"].concat(tokens),
+  // staticCss depends on tokens (for wildcards) and recipes (for recipe rules)
+  "static-css": ["staticCss", "patterns", "theme.recipes", "theme.slotRecipes"].concat(tokens),
+  // Split CSS artifacts (generated via cssgen --splitting)
+  styles: [],
+  "styles.css": []
+};
+var artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) => {
+  if (!paths.length) return () => void 0;
+  return createMatcher(key, paths.concat(all));
+});
+
+// src/diff-config.ts
+var runIfFn = (fn) => typeof fn === "function" ? fn() : fn;
+var hasRecipeStateTransition = (prevConfig, nextConfig) => {
+  const prevRecipes = prevConfig.theme?.recipes ?? {};
+  const prevSlotRecipes = prevConfig.theme?.slotRecipes ?? {};
+  const prevHasRecipes = Object.keys(prevRecipes).length > 0 || Object.keys(prevSlotRecipes).length > 0;
+  const nextRecipes = nextConfig.theme?.recipes ?? {};
+  const nextSlotRecipes = nextConfig.theme?.slotRecipes ?? {};
+  const nextHasRecipes = Object.keys(nextRecipes).length > 0 || Object.keys(nextSlotRecipes).length > 0;
+  return prevHasRecipes !== nextHasRecipes;
+};
+function diffConfigs(config, prevConfig) {
+  const affected = {
+    artifacts: /* @__PURE__ */ new Set(),
+    hasConfigChanged: false,
+    diffs: []
+  };
+  if (!prevConfig) {
+    affected.hasConfigChanged = true;
+    return affected;
+  }
+  const configDiff = (0, import_microdiff.default)(prevConfig, runIfFn(config));
+  if (!configDiff.length) {
+    return affected;
+  }
+  affected.hasConfigChanged = true;
+  affected.diffs = configDiff;
+  configDiff.forEach((change) => {
+    const changePath = change.path.join(".");
+    artifactMatchers.forEach((matcher) => {
+      const id = matcher(changePath);
+      if (!id) return;
+      if (id === "recipes") {
+        const name = (0, import_shared.dashCase)(change.path.slice(1, 3).join("."));
+        affected.artifacts.add(name);
+      }
+      if (id === "patterns") {
+        const name = (0, import_shared.dashCase)(change.path.slice(0, 2).join("."));
+        affected.artifacts.add(name);
+      }
+      affected.artifacts.add(id);
+    });
+  });
+  if (affected.artifacts.has("recipes") || affected.artifacts.has("recipes-index")) {
+    const nextConfig = runIfFn(config);
+    if (hasRecipeStateTransition(prevConfig, nextConfig)) {
+      affected.artifacts.add("create-recipe");
+    }
+  }
+  return affected;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffConfigs
+});

package/dist/diff-config.mjs

@@ -0,0 +1,6 @@
+import {
+  diffConfigs
+} from "./chunk-6TQW6KOI.mjs";
+export {
+  diffConfigs
+};