ui8kit 1.4.1 → 1.4.2

package/README.md

@@ -241,7 +241,8 @@ Options:
 - `[registry]` Path to registry JSON (default: `./src/registry.json`)
 - `-o, --output <path>` Output directory (default: `./packages/registry/r`)
 
-The build command also generates `packages/registry/ui8kit.map.json` when `src/lib/utility-props.map.ts` is available.
+The build command also generates `packages/registry/ui8kit.map.json` when
+`src/lib/utility-props.map.ts` is available.
 
 Generated map shape:
 
@@ -249,13 +250,23 @@ Generated map shape:
 {
   "version": "1.0.0",
   "generatedAt": "2026-03-06T12:00:00.000Z",
-  "map": {
-    "display": ["block", "flex"],
-    "spacing": ["m-2", "m-4"]
-  }
+  "map": [
+    "block",
+    "display-block",
+    "display-flex",
+    "m-2",
+    "m-4"
+  ]
 }
 ```
 
+`map` keeps the existing top-level envelope, but the value is now a flat string
+array of Tailwind classes. The generation reads both:
+
+- `src/lib/utility-props.map.ts` — grouped whitelist map by utility prefix.
+- `src/lib/utility-props.ts` — runtime rule source used for special
+  expansions (for example `flex` direction handling and semantic `gap` aliases).
+
 ### Global options
 
 These options work for all commands and are defined at the CLI root:

package/dist/index.js

@@ -66,6 +66,14 @@ var SCHEMA_CONFIG = {
     blocks: "./src/blocks",
     variants: "./src/variants"
   },
+  // Utility map generation settings
+  utilityMap: {
+    sources: {
+      mapFile: "./src/lib/utility-props.map.ts",
+      runtimeFile: "./src/lib/utility-props.ts"
+    },
+    outputFile: "./packages/registry/ui8kit.map.json"
+  },
   // Schema descriptions and titles
   descriptions: {
     config: {
@@ -2388,6 +2396,93 @@ function normalizeUtilityMap(raw) {
   }
   return ordered;
 }
+function toStringArray(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.map((item) => typeof item === "string" || typeof item === "number" ? String(item).trim() : "").filter((item) => item.length > 0);
+}
+function toStringRecord(raw) {
+  if (!isPlainObject(raw)) {
+    return {};
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof key === "string" && typeof value === "string") {
+      const normalizedValue = value.trim();
+      if (key.trim() && normalizedValue.length > 0) {
+        result[key.trim()] = normalizedValue;
+      }
+    }
+  }
+  return result;
+}
+function parseRuntimeExpansionRules(content) {
+  const sourceFile = ts2.createSourceFile(
+    "utility-props.ts",
+    content,
+    ts2.ScriptTarget.Latest,
+    true
+  );
+  const rules = {
+    flexDirections: /* @__PURE__ */ new Set(),
+    gapSemantic: {}
+  };
+  const visit = (node) => {
+    if (ts2.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (!ts2.isIdentifier(declaration.name) || !declaration.initializer) {
+          continue;
+        }
+        const value = parseObjectValue(declaration.initializer);
+        if (declaration.name.text === "FLEX_DIR_VALUES") {
+          const values = toStringArray(value);
+          rules.flexDirections = new Set(values);
+        }
+        if (declaration.name.text === "GAP_SEMANTIC") {
+          rules.gapSemantic = toStringRecord(value);
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return rules;
+}
+function expandUtilityValue(utility, rawValue, rules) {
+  const value = rawValue.trim();
+  if (value.length === 0) {
+    return [utility];
+  }
+  if (utility === "flex" && rules.flexDirections.has(value)) {
+    return ["flex", `flex-${value}`];
+  }
+  if (utility === "gap" && Object.prototype.hasOwnProperty.call(rules.gapSemantic, value)) {
+    return [`gap-${rules.gapSemantic[value]}`];
+  }
+  return [`${utility}-${value}`];
+}
+function buildFlatMap(utilityMap, rules) {
+  const flattened = [];
+  for (const [utility, rawValues] of Object.entries(utilityMap)) {
+    const normalizedUtility = utility.trim();
+    if (!normalizedUtility) {
+      continue;
+    }
+    for (const rawValue of rawValues) {
+      if (typeof rawValue !== "string") {
+        continue;
+      }
+      for (const value of expandUtilityValue(normalizedUtility, rawValue, rules)) {
+        const normalizedValue = value.trim();
+        if (normalizedValue.length > 0) {
+          flattened.push(normalizedValue);
+        }
+      }
+    }
+  }
+  return [...new Set(flattened)].sort();
+}
 function parseUtilityMapSource(content) {
   const fromJson = parseJsonCandidate(content);
   if (fromJson !== null) {
@@ -2400,7 +2495,12 @@ function parseUtilityMapSource(content) {
   throw new Error("Could not parse utility props map source");
 }
 async function generateMap(options) {
-  const { sourcePath, outputPath, skipMissing = true } = options;
+  const {
+    sourcePath,
+    runtimeSourcePath,
+    outputPath,
+    skipMissing = true
+  } = options;
   if (!await fs8.pathExists(sourcePath)) {
     if (skipMissing) {
       return { generated: false };
@@ -2410,10 +2510,19 @@ async function generateMap(options) {
   const content = await fs8.readFile(sourcePath, "utf-8");
   const rawMap = parseUtilityMapSource(content);
   const map = normalizeUtilityMap(rawMap);
+  let runtimeRules = {
+    flexDirections: /* @__PURE__ */ new Set(),
+    gapSemantic: {}
+  };
+  if (runtimeSourcePath && await fs8.pathExists(runtimeSourcePath)) {
+    const runtimeContent = await fs8.readFile(runtimeSourcePath, "utf-8");
+    runtimeRules = parseRuntimeExpansionRules(runtimeContent);
+  }
+  const flattenedMap = buildFlatMap(map, runtimeRules);
   const mapFile = {
     version: "1.0.0",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    map
+    map: flattenedMap
   };
   await fs8.ensureDir(path9.dirname(outputPath));
   await fs8.writeJson(outputPath, mapFile, { spaces: 2 });
@@ -2458,10 +2567,13 @@ async function buildCommand(registryPath = "./src/registry.json", options = {})
     }
     spinner.succeed(CLI_MESSAGES.status.builtComponents(registry.items.length));
     await createIndexFile(registry, buildOptions.outputDir);
-    const mapSourcePath = path10.join(buildOptions.cwd, "src", "lib", "utility-props.map.ts");
-    const mapOutputPath = path10.join(path10.dirname(buildOptions.outputDir), "ui8kit.map.json");
+    const mapSourcePath = path10.join(buildOptions.cwd, SCHEMA_CONFIG.utilityMap.sources.mapFile);
+    const runtimeSourcePath = path10.join(buildOptions.cwd, SCHEMA_CONFIG.utilityMap.sources.runtimeFile);
+    const mapFileName = path10.basename(SCHEMA_CONFIG.utilityMap.outputFile);
+    const mapOutputPath = path10.join(path10.dirname(buildOptions.outputDir), mapFileName);
     const mapResult = await generateMap({
       sourcePath: mapSourcePath,
+      runtimeSourcePath,
       outputPath: mapOutputPath,
       skipMissing: true
     });