@tokens-studio/tokenscript-schemas 0.1.2 → 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
 
@@ -39,12 +44,19 @@ npx @tokens-studio/tokenscript-schemas bundle --config schemas.json
 # Preview what would be bundled (dry-run)
 npx @tokens-studio/tokenscript-schemas bundle oklch-color rgb-color --dry-run
 
+# Bundle from custom schema directory
+npx @tokens-studio/tokenscript-schemas bundle type:my-color -o ./schemas.js --schemas-dir ./my-schemas
+
 # List available schemas
 npx @tokens-studio/tokenscript-schemas list
 npx @tokens-studio/tokenscript-schemas list --types
 npx @tokens-studio/tokenscript-schemas list --functions
 ```
 
+#### Docs
+
+- [Custom Schema Directories Documentation](docs/cli/custom-schemas.md) - Bundle schemas from custom directories
+
 ### Available Presets
 
 - **`preset:css`** - Modern CSS color types (CSS Color Level 4+)
@@ -120,19 +132,36 @@ src/schemas/types/srgb-color/
 - Tests use runtime bundling - no build step required
 - The bundler inlines script content for distribution
 
+## Working with Custom Schemas
+
+You can use the bundler with your own custom schema directories, useful for:
+- Developing experimental schemas without modifying the main repository
+- Working with schemas from external projects
+- Testing new color types before committing them
+
+See **[Custom Schema Directories Documentation](docs/cli/custom-schemas.md)** for detailed examples and usage.
+
+```bash
+# Bundle from custom directory
+npm run cli -- bundle my-color -o ./output.js --schemas-dir ./path/to/custom/schemas
+
+# Build from custom directory
+npm run build-schemas -- --schemas-dir ./path/to/custom/schemas
+```
+
 ## Scripts
 
-### Bundle Schemas
+### Build Schemas
 
 ```bash
-npm run bundle
+npm run build-schemas
 ```
 
-Bundles all schemas using the **shared bundling logic** from `@/bundler/bundle-schema.ts`:
+Builds all schemas using the **shared build logic** from `@/bundler/build-schema.ts`:
 - Reads `schema.json` from each schema directory
 - Finds all `./file.tokenscript` references in the schema
 - Reads and inlines the script file content
-- Outputs bundled schemas to `bundled/` directory:
+- Outputs built schemas to `result/` directory:
   - `registry.json` - Complete registry
   - `types.json` - All type schemas
   - `functions.json` - All function schemas
@@ -163,9 +192,9 @@ npm test -- src/schemas/types/rgb-color/unit.test.ts
 - Logs are **disabled by default** to reduce noise (only errors shown)
 - Use `LOG_LEVEL` environment variable to enable logs: `debug`, `info`, `warn`, `error`
 - See [tests/helpers/LOGGING.md](tests/helpers/LOGGING.md) for detailed logging documentation
-- Tests use `bundleSchemaFromDirectory()` from `@/bundler/bundle-schema.ts`
-- No build step required - schemas are bundled on-demand
-- Same bundling logic as build-time for consistency
+- Tests use `buildSchemaFromDirectory()` from `@/bundler/build-schema.ts`
+- No build step required - schemas are built on-demand
+- Same build logic as build-time for consistency
 
 ## Links
 

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,50 +21,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 = path.join(schemaDir, "schema.json");
   const schemaContent = await promises.readFile(schemaJsonPath, "utf-8");
   const schema = JSON.parse(schemaContent);
@@ -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;
@@ -290,9 +333,9 @@ async function collectRequiredSchemas(slugOrUri, type, options = {}) {
       const categoryDir = effectiveType === "type" ? "types" : "functions";
       const resolvedSchemasDir = schemasDir || process.env.SCHEMAS_DIR || path.join(process.cwd(), "src/schemas");
       const schemaDir = path.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);
@@ -344,7 +387,7 @@ async function collectDependencyTree(schemas, options = {}) {
     const resolvedSchemasDir = schemasDir || process.env.SCHEMAS_DIR || path.join(process.cwd(), "src/schemas");
     const schemaDir = path.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);
@@ -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;
@@ -418,7 +461,7 @@ async function bundleSelectiveSchemas(options) {
   const bundledSchemas = [];
   for (const typeSlug of deps.types) {
     const schemaDir = path.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({
@@ -429,7 +472,7 @@ async function bundleSelectiveSchemas(options) {
   }
   for (const funcSlug of deps.functions) {
     const schemaDir = path.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({
@@ -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 = 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({
@@ -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) {
@@ -677,9 +716,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("");
@@ -692,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);
@@ -732,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) {
@@ -743,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 };
@@ -775,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));
@@ -819,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").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);
   }
 });
@@ -844,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);
   }
 });
@@ -852,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);
   }
 });