@tokens-studio/tokenscript-schemas 0.1.2 → 0.2.0

package/dist/cli/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import cac from 'cac';
-import ulog from 'ulog';
+import anylogger from 'ulog';
+import { existsSync, readFileSync } from 'fs';
 import { mkdir, writeFile, readFile, readdir, access } from 'fs/promises';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import 'child_process';
-import { readFileSync } from 'fs';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -13,50 +13,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-
-// src/bundler/presets/css.ts
-var css = {
-  name: "CSS",
-  description: "CSS color types",
-  types: [
-    "hex-color",
-    "rgb-color",
-    "hsl-color",
-    "oklch-color",
-    "oklab-color",
-    // Converting colors to css strings
-    "css-color"
-  ],
-  functions: ["lighten", "darken", "saturate", "desaturate", "mix", "invert"]
-};
-
-// src/bundler/presets/index.ts
-var BUNDLE_PRESETS = {
-  css
-};
-function expandPresetSchemas(schemas) {
-  const expanded = [];
-  for (const schema of schemas) {
-    if (schema.startsWith("preset:")) {
-      const presetName = schema.slice(7);
-      const preset = BUNDLE_PRESETS[presetName];
-      if (preset) {
-        for (const type of preset.types) {
-          expanded.push(type === "*" ? "*" : `type:${type}`);
-        }
-        for (const func of preset.functions) {
-          expanded.push(func === "*" ? "*" : `function:${func}`);
-        }
-      } else {
-        console.warn(`\u26A0 Unknown preset: ${presetName}`);
-      }
-    } else {
-      expanded.push(schema);
-    }
-  }
-  return expanded;
-}
-async function bundleSchemaFromDirectory(schemaDir, options) {
+async function buildSchemaFromDirectory(schemaDir, options) {
   const schemaJsonPath = join(schemaDir, "schema.json");
   const schemaContent = await readFile(schemaJsonPath, "utf-8");
   const schema = JSON.parse(schemaContent);
@@ -126,6 +83,92 @@ function addBaseUrl(uri, baseUrl) {
   }
   return uri;
 }
+
+// src/cli/commands/build-dir.ts
+var log = anylogger("build-dir");
+async function buildSchemaDir(schemaDir, options = {}) {
+  const resolvedDir = resolveSchemaDir(schemaDir);
+  if (!existsSync(resolvedDir)) {
+    throw new Error(`Directory not found: ${resolvedDir}`);
+  }
+  const schemaJsonPath = join(resolvedDir, "schema.json");
+  if (!existsSync(schemaJsonPath)) {
+    throw new Error(`schema.json not found in: ${resolvedDir}`);
+  }
+  log.info(`Building schema from: ${resolvedDir}`);
+  const schema = await buildSchemaFromDirectory(resolvedDir);
+  const output = options.pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema);
+  if (options.output) {
+    await mkdir(dirname(options.output), { recursive: true });
+    await writeFile(options.output, output, "utf-8");
+    log.info(`Output written to: ${options.output}`);
+    console.log(`\u2713 Built ${schema.type}:${schema.name} \u2192 ${options.output}`);
+  } else {
+    console.log(output);
+  }
+}
+function resolveSchemaDir(schemaDir) {
+  if (existsSync(schemaDir)) {
+    return schemaDir;
+  }
+  const cwd = process.cwd();
+  const fromCwd = join(cwd, schemaDir);
+  if (existsSync(fromCwd)) {
+    return fromCwd;
+  }
+  return schemaDir;
+}
+async function handleBuildCommand(schemaDir, options = {}) {
+  try {
+    await buildSchemaDir(schemaDir, options);
+  } catch (error) {
+    log.error("Build failed:", error);
+    throw error;
+  }
+}
+
+// src/bundler/presets/css.ts
+var css = {
+  name: "CSS",
+  description: "CSS color types",
+  types: [
+    "hex-color",
+    "rgb-color",
+    "hsl-color",
+    "oklch-color",
+    "oklab-color",
+    // Converting colors to css strings
+    "css-color"
+  ],
+  functions: ["lighten", "darken", "saturate", "desaturate", "mix", "invert"]
+};
+
+// src/bundler/presets/index.ts
+var BUNDLE_PRESETS = {
+  css
+};
+function expandPresetSchemas(schemas) {
+  const expanded = [];
+  for (const schema of schemas) {
+    if (schema.startsWith("preset:")) {
+      const presetName = schema.slice(7);
+      const preset = BUNDLE_PRESETS[presetName];
+      if (preset) {
+        for (const type of preset.types) {
+          expanded.push(type === "*" ? "*" : `type:${type}`);
+        }
+        for (const func of preset.functions) {
+          expanded.push(func === "*" ? "*" : `function:${func}`);
+        }
+      } else {
+        console.warn(`\u26A0 Unknown preset: ${presetName}`);
+      }
+    } else {
+      expanded.push(schema);
+    }
+  }
+  return expanded;
+}
 var LOG_LEVELS = {
   error: 1,
   warn: 2,
@@ -133,9 +176,9 @@ var LOG_LEVELS = {
   log: 4,
   debug: 5
 };
-var log = ulog("schema-registry");
+var log2 = anylogger("schema-registry");
 var logLevel = process.env.LOG_LEVEL || "error";
-log.level = LOG_LEVELS[logLevel] || LOG_LEVELS.error;
+log2.level = LOG_LEVELS[logLevel] || LOG_LEVELS.error;
 
 // src/utils/type.ts
 var isSome = (v) => {
@@ -267,7 +310,7 @@ async function collectRequiredSchemas(slugOrUri, type, options = {}) {
   async function traverse(currentSlugOrUri, currentType) {
     const ref = resolveSchemaReference(currentSlugOrUri);
     if (!ref) {
-      log.warn(`Could not resolve schema reference: ${currentSlugOrUri}`);
+      log2.warn(`Could not resolve schema reference: ${currentSlugOrUri}`);
       return;
     }
     const effectiveType = currentType || ref.type;
@@ -282,9 +325,9 @@ async function collectRequiredSchemas(slugOrUri, type, options = {}) {
       const categoryDir = effectiveType === "type" ? "types" : "functions";
       const resolvedSchemasDir = schemasDir || process.env.SCHEMAS_DIR || join(process.cwd(), "src/schemas");
       const schemaDir = join(resolvedSchemasDir, categoryDir, slug);
-      spec = await bundleSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : void 0);
+      spec = await buildSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : void 0);
     } catch (error) {
-      log.warn(`Failed to load schema ${slug} (${effectiveType}):`, error);
+      log2.warn(`Failed to load schema ${slug} (${effectiveType}):`, error);
       return;
     }
     const requirements = extractRequirements(spec, extractOptions);
@@ -336,7 +379,7 @@ async function collectDependencyTree(schemas, options = {}) {
     const resolvedSchemasDir = schemasDir || process.env.SCHEMAS_DIR || join(process.cwd(), "src/schemas");
     const schemaDir = join(resolvedSchemasDir, categoryDir, schema.slug);
     try {
-      const spec = await bundleSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : void 0);
+      const spec = await buildSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : void 0);
       const requirements = extractRequirements(spec, extractOptions);
       const dependencySlugs = requirements.map((uri) => {
         const ref = resolveSchemaReference(uri);
@@ -349,7 +392,7 @@ async function collectDependencyTree(schemas, options = {}) {
         dependencies: dependencySlugs
       });
     } catch (error) {
-      log.warn(`Failed to load schema ${schema.slug} (${schema.type}):`, error);
+      log2.warn(`Failed to load schema ${schema.slug} (${schema.type}):`, error);
     }
   }
   return tree;
@@ -410,7 +453,7 @@ async function bundleSelectiveSchemas(options) {
   const bundledSchemas = [];
   for (const typeSlug of deps.types) {
     const schemaDir = join(schemasDir, "types", typeSlug);
-    const bundled = await bundleSchemaFromDirectory(schemaDir, { baseUrl });
+    const bundled = await buildSchemaFromDirectory(schemaDir, { baseUrl });
     if (bundled.type === "color") {
       const uri = `${baseUrl}/api/v1/core/${typeSlug}/0/`;
       bundledSchemas.push({
@@ -421,7 +464,7 @@ async function bundleSelectiveSchemas(options) {
   }
   for (const funcSlug of deps.functions) {
     const schemaDir = join(schemasDir, "functions", funcSlug);
-    const bundled = await bundleSchemaFromDirectory(schemaDir, { baseUrl });
+    const bundled = await buildSchemaFromDirectory(schemaDir, { baseUrl });
     if (bundled.type === "function") {
       const uri = `${baseUrl}/api/v1/function/${funcSlug}/0/`;
       bundledSchemas.push({
@@ -540,7 +583,7 @@ function generateOutput(options) {
 }
 
 // src/cli/commands/bundle.ts
-var log2 = ulog("bundle");
+var log3 = anylogger("bundle");
 async function loadConfig(configPath) {
   try {
     const content = await readFile(configPath, "utf-8");
@@ -605,28 +648,24 @@ function findSchemasDir() {
   const __dirname2 = dirname(__filename2);
   const fromDist = join(__dirname2, "../../src/schemas");
   const fromSource = join(__dirname2, "../../schemas");
-  try {
-    const fs = __require("fs");
-    if (fs.existsSync(fromDist)) {
-      return fromDist;
-    }
-    if (fs.existsSync(fromSource)) {
-      return fromSource;
-    }
-  } catch {
+  if (existsSync(fromSource)) {
+    return fromSource;
   }
-  return fromDist;
+  if (existsSync(fromDist)) {
+    return fromDist;
+  }
+  return fromSource;
 }
 async function bundleSchemas(schemas, schemasDir, cliArgs) {
-  const resolvedSchemasDir = findSchemasDir();
-  log2.info("Bundling schemas:", schemas);
-  log2.debug("Schemas directory:", resolvedSchemasDir);
+  const resolvedSchemasDir = schemasDir || findSchemasDir();
+  log3.info("Bundling schemas:", schemas);
+  log3.debug("Schemas directory:", resolvedSchemasDir);
   const result = await bundleSelectiveSchemas({
     schemas,
     schemasDir: resolvedSchemasDir,
     cliArgs
   });
-  log2.info(
+  log3.info(
     `Resolved ${result.metadata.resolvedDependencies.length} schemas (including dependencies)`
   );
   const output = generateOutput({
@@ -645,7 +684,7 @@ async function handleBundleCommand(schemas, options = {}) {
     let configSchemas = schemas;
     let outputPath = options.output || "./tokenscript-schemas.js";
     if (isSome(options.config)) {
-      log2.info(`Loading config from ${options.config}`);
+      log3.info(`Loading config from ${options.config}`);
       const config = await loadConfig(options.config);
       configSchemas = config.schemas;
       if (config.output) {
@@ -669,9 +708,16 @@ async function handleBundleCommand(schemas, options = {}) {
     if (options.dryRun) {
       cliArgs.push("--dry-run");
     }
+    if (options.schemasDir) {
+      cliArgs.push("--schemas-dir", options.schemasDir);
+    }
+    const customSchemasDir = options.schemasDir;
+    if (customSchemasDir) {
+      log3.info(`Using custom schema directory: ${customSchemasDir}`);
+    }
     const { output, metadata, dependencyTree } = await bundleSchemas(
       configSchemas,
-      void 0,
+      customSchemasDir,
       cliArgs
     );
     console.log("");
@@ -684,15 +730,15 @@ async function handleBundleCommand(schemas, options = {}) {
     }
     await mkdir(dirname(outputPath), { recursive: true });
     await writeFile(outputPath, output, "utf-8");
-    log2.info(`Successfully bundled ${metadata.resolvedDependencies.length} schemas`);
-    log2.info(`Output written to: ${outputPath}`);
+    log3.info(`Successfully bundled ${metadata.resolvedDependencies.length} schemas`);
+    log3.info(`Output written to: ${outputPath}`);
     console.log(`\u2713 Bundled ${metadata.resolvedDependencies.length} schemas \u2192 ${outputPath}`);
   } catch (error) {
-    log2.error("Bundle failed:", error);
+    log3.error("Bundle failed:", error);
     throw error;
   }
 }
-var log3 = ulog("list");
+var log4 = anylogger("list");
 function findSchemasDir2() {
   const __filename2 = fileURLToPath(import.meta.url);
   const __dirname2 = dirname(__filename2);
@@ -724,7 +770,7 @@ async function listSchemas(schemasDir, options = {}) {
         ...typeEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
       );
     } catch (error) {
-      log3.warn("Could not read types directory:", error);
+      log4.warn("Could not read types directory:", error);
     }
   }
   if (showFunctions) {
@@ -735,7 +781,7 @@ async function listSchemas(schemasDir, options = {}) {
         ...funcEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
       );
     } catch (error) {
-      log3.warn("Could not read functions directory:", error);
+      log4.warn("Could not read functions directory:", error);
     }
   }
   return { types, functions };
@@ -767,7 +813,7 @@ async function handleListCommand(options = {}) {
   const output = formatListOutput(result, options);
   console.log(output);
 }
-var log4 = ulog("presets");
+var log5 = anylogger("presets");
 function formatPresetInfo() {
   const lines = [];
   lines.push("=".repeat(60));
@@ -811,24 +857,32 @@ function formatPresetInfo() {
 }
 async function handlePresetsCommand() {
   try {
-    log4.info("Listing available presets");
+    log5.info("Listing available presets");
     const output = formatPresetInfo();
     console.log(output);
-    log4.info(`Listed ${Object.keys(BUNDLE_PRESETS).length} presets`);
+    log5.info(`Listed ${Object.keys(BUNDLE_PRESETS).length} presets`);
   } catch (error) {
-    log4.error("Failed to list presets:", error);
+    log5.error("Failed to list presets:", error);
     throw error;
   }
 }
 
 // src/cli/index.ts
-var log5 = ulog("cli");
+var log6 = anylogger("cli");
 var cli = cac("tokenscript-schemas");
-cli.command("bundle [...schemas]", "Bundle schemas into a JS file").option("-c, --config <path>", "Path to config file").option("-o, --output <path>", "Output file path", { default: "./tokenscript-schemas.js" }).option("-d, --dry-run", "Preview what would be bundled without writing").action(async (schemas, options) => {
+cli.command("bundle [...schemas]", "Bundle schemas into a JS file").option("-c, --config <path>", "Path to config file").option("-o, --output <path>", "Output file path", { default: "./tokenscript-schemas.js" }).option("-d, --dry-run", "Preview what would be bundled without writing").option("-s, --schemas-dir <path>", "Custom schema directory (overrides default)").action(async (schemas, options) => {
   try {
     await handleBundleCommand(schemas, options);
   } catch (error) {
-    log5.error("Error:", error);
+    log6.error("Error:", error);
+    process.exit(1);
+  }
+});
+cli.command("build <directory>", "Build an individual schema directory").option("-o, --output <path>", "Output file path (defaults to stdout)").option("-p, --pretty", "Pretty print JSON output").action(async (directory, options) => {
+  try {
+    await handleBuildCommand(directory, options);
+  } catch (error) {
+    log6.error("Error:", error);
     process.exit(1);
   }
 });
@@ -836,7 +890,7 @@ cli.command("list", "List available schemas").option("--types", "List only type
   try {
     await handleListCommand(options);
   } catch (error) {
-    log5.error("Error:", error);
+    log6.error("Error:", error);
     process.exit(1);
   }
 });
@@ -844,7 +898,7 @@ cli.command("presets", "List available bundle presets").action(async () => {
   try {
     await handlePresetsCommand();
   } catch (error) {
-    log5.error("Error:", error);
+    log6.error("Error:", error);
     process.exit(1);
   }
 });