@tokens-studio/tokenscript-schemas 0.1.3 → 0.2.0

package/README.md

@@ -30,6 +30,11 @@ npx @tokens-studio/tokenscript-schemas bundle oklch-color rgb-color -o ./schemas
 # Bundle with functions
 npx @tokens-studio/tokenscript-schemas bundle rgb-color function:invert -o ./schemas.js
 
+# Build individual schema directory
+npx @tokens-studio/tokenscript-schemas build ./src/schemas/types/css-color
+npx @tokens-studio/tokenscript-schemas build ./src/schemas/types/css-color -o css-color.json
+npx @tokens-studio/tokenscript-schemas build ./src/schemas/types/css-color --pretty -o css-color.json
+
 # Combine presets with specific schemas
 npx @tokens-studio/tokenscript-schemas bundle preset:css type:lab-color -o ./schemas.js
 

package/dist/cli/index.cjs

@@ -2,18 +2,18 @@
 'use strict';
 
 var cac = require('cac');
-var ulog = require('ulog');
+var anylogger = require('ulog');
+var fs = require('fs');
 var promises = require('fs/promises');
 var path = require('path');
 var url = require('url');
 require('child_process');
-var fs = require('fs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var cac__default = /*#__PURE__*/_interopDefault(cac);
-var ulog__default = /*#__PURE__*/_interopDefault(ulog);
+var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -21,49 +21,6 @@ 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 buildSchemaFromDirectory(schemaDir, options) {
   const schemaJsonPath = path.join(schemaDir, "schema.json");
   const schemaContent = await promises.readFile(schemaJsonPath, "utf-8");
@@ -134,6 +91,92 @@ function addBaseUrl(uri, baseUrl) {
   }
   return uri;
 }
+
+// src/cli/commands/build-dir.ts
+var log = anylogger__default.default("build-dir");
+async function buildSchemaDir(schemaDir, options = {}) {
+  const resolvedDir = resolveSchemaDir(schemaDir);
+  if (!fs.existsSync(resolvedDir)) {
+    throw new Error(`Directory not found: ${resolvedDir}`);
+  }
+  const schemaJsonPath = path.join(resolvedDir, "schema.json");
+  if (!fs.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 promises.mkdir(path.dirname(options.output), { recursive: true });
+    await promises.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 (fs.existsSync(schemaDir)) {
+    return schemaDir;
+  }
+  const cwd = process.cwd();
+  const fromCwd = path.join(cwd, schemaDir);
+  if (fs.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,
@@ -141,9 +184,9 @@ var LOG_LEVELS = {
   log: 4,
   debug: 5
 };
-var log = ulog__default.default("schema-registry");
+var log2 = anylogger__default.default("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) => {
@@ -275,7 +318,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;
@@ -292,7 +335,7 @@ async function collectRequiredSchemas(slugOrUri, type, options = {}) {
       const schemaDir = path.join(resolvedSchemasDir, categoryDir, slug);
       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);
@@ -357,7 +400,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;
@@ -548,7 +591,7 @@ function generateOutput(options) {
 }
 
 // src/cli/commands/bundle.ts
-var log2 = ulog__default.default("bundle");
+var log3 = anylogger__default.default("bundle");
 async function loadConfig(configPath) {
   try {
     const content = await promises.readFile(configPath, "utf-8");
@@ -613,28 +656,24 @@ function findSchemasDir() {
   const __dirname2 = path.dirname(__filename2);
   const fromDist = path.join(__dirname2, "../../src/schemas");
   const fromSource = path.join(__dirname2, "../../schemas");
-  try {
-    const fs = __require("fs");
-    if (fs.existsSync(fromDist)) {
-      return fromDist;
-    }
-    if (fs.existsSync(fromSource)) {
-      return fromSource;
-    }
-  } catch {
+  if (fs.existsSync(fromSource)) {
+    return fromSource;
   }
-  return fromDist;
+  if (fs.existsSync(fromDist)) {
+    return fromDist;
+  }
+  return fromSource;
 }
 async function bundleSchemas(schemas, schemasDir, cliArgs) {
   const resolvedSchemasDir = schemasDir || findSchemasDir();
-  log2.info("Bundling schemas:", schemas);
-  log2.debug("Schemas directory:", resolvedSchemasDir);
+  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({
@@ -653,7 +692,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) {
@@ -682,7 +721,7 @@ async function handleBundleCommand(schemas, options = {}) {
     }
     const customSchemasDir = options.schemasDir;
     if (customSchemasDir) {
-      log2.info(`Using custom schema directory: ${customSchemasDir}`);
+      log3.info(`Using custom schema directory: ${customSchemasDir}`);
     }
     const { output, metadata, dependencyTree } = await bundleSchemas(
       configSchemas,
@@ -699,15 +738,15 @@ async function handleBundleCommand(schemas, options = {}) {
     }
     await promises.mkdir(path.dirname(outputPath), { recursive: true });
     await promises.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__default.default("list");
+var log4 = anylogger__default.default("list");
 function findSchemasDir2() {
   const __filename2 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
   const __dirname2 = path.dirname(__filename2);
@@ -739,7 +778,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) {
@@ -750,7 +789,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 };
@@ -782,7 +821,7 @@ async function handleListCommand(options = {}) {
   const output = formatListOutput(result, options);
   console.log(output);
 }
-var log4 = ulog__default.default("presets");
+var log5 = anylogger__default.default("presets");
 function formatPresetInfo() {
   const lines = [];
   lines.push("=".repeat(60));
@@ -826,24 +865,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__default.default("cli");
+var log6 = anylogger__default.default("cli");
 var cli = cac__default.default("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").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);
   }
 });
@@ -851,7 +898,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);
   }
 });
@@ -859,7 +906,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);
   }
 });