@terrazzo/parser 2.0.0-alpha.7 → 2.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terrazzo/parser",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-beta.0",
   "description": "Parser/validator for the Design Tokens Community Group (DTCG) standard.",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@humanwhocodes/momoa": "^3.3.10",
-    "@types/babel__code-frame": "^7.0.6",
+    "@types/babel__code-frame": "^7.27.0",
     "@types/culori": "^4.0.1",
     "culori": "^4.0.2",
     "fast-deep-equal": "^3.1.3",
@@ -44,7 +44,7 @@
     "scule": "^1.3.0",
     "wildcard-match": "^5.1.4",
     "@terrazzo/json-schema-tools": "^0.2.0",
-    "@terrazzo/token-tools": "^2.0.0-alpha.7"
+    "@terrazzo/token-tools": "^2.0.0-beta.0"
   },
   "peerDependencies": {
     "yaml-to-momoa": "0.0.8"

package/src/build/index.ts

@@ -1,209 +0,0 @@
-import type { InputSourceWithDocument } from '@terrazzo/json-schema-tools';
-import type { TokenNormalized } from '@terrazzo/token-tools';
-import wcmatch from 'wildcard-match';
-import Logger, { type LogEntry } from '../logger.js';
-import type { BuildRunnerResult, ConfigInit, Resolver, TokenTransformed, TransformParams } from '../types.js';
-
-export interface BuildRunnerOptions {
-  sources: InputSourceWithDocument[];
-  config: ConfigInit;
-  resolver: Resolver;
-  logger?: Logger;
-}
-export const SINGLE_VALUE = 'SINGLE_VALUE';
-export const MULTI_VALUE = 'MULTI_VALUE';
-
-/** Validate plugin setTransform() calls for immediate feedback */
-function validateTransformParams({
-  params,
-  logger,
-  pluginName,
-}: {
-  params: TokenTransformed;
-  logger: Logger;
-  pluginName: string;
-}): void {
-  const baseMessage: LogEntry = { group: 'plugin', label: pluginName, message: '' };
-
-  // validate value is valid for SINGLE_VALUE or MULTI_VALUE
-  if (
-    !params.value ||
-    (typeof params.value !== 'string' && typeof params.value !== 'object') ||
-    Array.isArray(params.value)
-  ) {
-    logger.error({
-      ...baseMessage,
-      message: `setTransform() value expected string or object of strings, received ${
-        Array.isArray(params.value) ? 'Array' : typeof params.value
-      }`,
-    });
-  }
-  if (typeof params.value === 'object' && Object.values(params.value).some((v) => typeof v !== 'string')) {
-    logger.error({
-      ...baseMessage,
-      message: 'setTransform() value expected object of strings, received some non-string values',
-    });
-  }
-}
-
-/** Run build stage */
-export default async function build(
-  tokens: Record<string, TokenNormalized>,
-  { resolver, sources, logger = new Logger(), config }: BuildRunnerOptions,
-): Promise<BuildRunnerResult> {
-  const formats: Record<string, TokenTransformed[]> = {};
-  const result: BuildRunnerResult = { outputFiles: [] };
-
-  function getTransforms(params: TransformParams) {
-    if (!params?.format) {
-      logger.warn({ group: 'plugin', message: '"format" missing from getTransforms(), no tokens returned.' });
-      return [];
-    }
-
-    const tokenMatcher = params.id ? wcmatch(Array.isArray(params.id) ? params.id : [params.id]) : null;
-    const modeMatcher = params.mode ? wcmatch(params.mode) : null;
-
-    return (formats[params.format!] ?? []).filter((token) => {
-      if (params.$type) {
-        if (typeof params.$type === 'string' && token.token.$type !== params.$type) {
-          return false;
-        } else if (Array.isArray(params.$type) && !params.$type.some(($type) => token.token.$type === $type)) {
-          return false;
-        }
-      }
-      if (params.id && params.id !== '*' && tokenMatcher && !tokenMatcher(token.token.id)) {
-        return false;
-      }
-      if (modeMatcher && !modeMatcher(token.mode)) {
-        return false;
-      }
-      return true;
-    });
-  }
-
-  // transform()
-  let transformsLocked = false; // prevent plugins from transforming after stage has ended
-  const startTransform = performance.now();
-  for (const plugin of config.plugins) {
-    if (typeof plugin.transform === 'function') {
-      await plugin.transform({
-        context: { logger },
-        tokens,
-        sources,
-        getTransforms,
-        setTransform(id, params) {
-          if (transformsLocked) {
-            logger.warn({
-              message: 'Attempted to call setTransform() after transform step has completed.',
-              group: 'plugin',
-              label: plugin.name,
-            });
-            return;
-          }
-          const token = tokens[id]!;
-
-          const cleanValue: TokenTransformed['value'] =
-            typeof params.value === 'string' ? params.value : { ...(params.value as Record<string, string>) };
-          validateTransformParams({
-            logger,
-            params: { ...(params as any), value: cleanValue },
-            pluginName: plugin.name,
-          });
-
-          // upsert
-          if (!formats[params.format]) {
-            formats[params.format] = [];
-          }
-          const foundTokenI = formats[params.format]!.findIndex(
-            (t) =>
-              id === t.id &&
-              (!params.localID || params.localID === t.localID) &&
-              (!params.mode || params.mode === t.mode),
-          );
-          if (foundTokenI === -1) {
-            formats[params.format]!.push({
-              ...params,
-              id,
-              value: cleanValue,
-              type: typeof cleanValue === 'string' ? SINGLE_VALUE : MULTI_VALUE,
-              mode: params.mode || '.',
-              token: structuredClone(token),
-            } as TokenTransformed);
-          } else {
-            formats[params.format]![foundTokenI]!.value = cleanValue;
-            formats[params.format]![foundTokenI]!.type = typeof cleanValue === 'string' ? SINGLE_VALUE : MULTI_VALUE;
-          }
-        },
-        resolver,
-      });
-    }
-  }
-  transformsLocked = true;
-  logger.debug({
-    group: 'parser',
-    label: 'transform',
-    message: 'transform() step',
-    timing: performance.now() - startTransform,
-  });
-
-  // build()
-  const startBuild = performance.now();
-  await Promise.all(
-    config.plugins.map(async (plugin) => {
-      if (typeof plugin.build === 'function') {
-        const pluginBuildStart = performance.now();
-        await plugin.build({
-          context: { logger },
-          tokens,
-          sources,
-          getTransforms,
-          resolver,
-          outputFile(filename, contents) {
-            const resolved = new URL(filename, config.outDir);
-            if (result.outputFiles.some((f) => new URL(f.filename, config.outDir).href === resolved.href)) {
-              logger.error({
-                group: 'plugin',
-                message: `Can’t overwrite file "${filename}"`,
-                label: plugin.name,
-              });
-            }
-            result.outputFiles.push({
-              filename,
-              contents,
-              plugin: plugin.name,
-              time: performance.now() - pluginBuildStart,
-            });
-          },
-        });
-      }
-    }),
-  );
-  logger.debug({
-    group: 'parser',
-    label: 'build',
-    message: 'build() step',
-    timing: performance.now() - startBuild,
-  });
-
-  // buildEnd()
-  const startBuildEnd = performance.now();
-  await Promise.all(
-    config.plugins.map(async (plugin) =>
-      plugin.buildEnd?.({
-        context: { logger },
-        tokens,
-        getTransforms,
-        sources,
-        outputFiles: structuredClone(result.outputFiles),
-      }),
-    ),
-  );
-  logger.debug({
-    group: 'parser',
-    label: 'build',
-    message: 'buildEnd() step',
-    timing: performance.now() - startBuildEnd,
-  });
-
-  return result;
-}

package/src/config.ts

@@ -1,304 +0,0 @@
-import { merge } from 'merge-anything';
-import coreLintPlugin, { RECOMMENDED_CONFIG } from './lint/plugin-core/index.js';
-import Logger from './logger.js';
-import type { Config, ConfigInit, ConfigOptions, LintRuleSeverity } from './types.js';
-
-const TRAILING_SLASH_RE = /\/*$/;
-
-/**
- * Validate and normalize a config
- */
-export default function defineConfig(
-  rawConfig: Config,
-  { logger = new Logger(), cwd }: ConfigOptions = {} as ConfigOptions,
-): ConfigInit {
-  const configStart = performance.now();
-
-  if (!cwd) {
-    logger.error({ group: 'config', label: 'core', message: 'defineConfig() missing `cwd` for JS API' });
-  }
-
-  const config = merge({}, rawConfig) as unknown as ConfigInit;
-
-  // 1. normalize and init
-  normalizeTokens({ rawConfig, config, logger, cwd });
-  normalizeOutDir({ config, cwd, logger });
-  normalizePlugins({ config, logger });
-  normalizeLint({ config, logger });
-  normalizeIgnore({ config, logger });
-
-  // 2. Start build by calling config()
-  for (const plugin of config.plugins) {
-    plugin.config?.({ ...config }, { logger });
-  }
-
-  // 3. finish
-  logger.debug({
-    group: 'parser',
-    label: 'config',
-    message: 'Finish config validation',
-    timing: performance.now() - configStart,
-  });
-  return config;
-}
-
-/** Normalize config.tokens */
-function normalizeTokens({
-  rawConfig,
-  config,
-  logger,
-  cwd,
-}: {
-  rawConfig: Config;
-  config: ConfigInit;
-  logger: Logger;
-  cwd: URL;
-}) {
-  if (rawConfig.tokens === undefined) {
-    config.tokens = [
-      // @ts-expect-error we’ll normalize in next step
-      './tokens.json',
-    ];
-  } else if (typeof rawConfig.tokens === 'string') {
-    config.tokens = [
-      // @ts-expect-error we’ll normalize in next step
-      rawConfig.tokens,
-    ];
-  } else if (Array.isArray(rawConfig.tokens)) {
-    config.tokens = [];
-    for (const file of rawConfig.tokens) {
-      if (typeof file === 'string' || (file as URL) instanceof URL) {
-        config.tokens.push(
-          // @ts-expect-error we’ll normalize in next step
-          file,
-        );
-      } else {
-        logger.error({
-          group: 'config',
-          label: 'tokens',
-          message: `Expected array of strings, encountered ${JSON.stringify(file)}`,
-        });
-      }
-    }
-  } else {
-    logger.error({
-      group: 'config',
-      label: 'tokens',
-      message: `Expected string or array of strings, received ${typeof rawConfig.tokens}`,
-    });
-  }
-  for (let i = 0; i < config.tokens!.length; i++) {
-    const filepath = config.tokens[i]!;
-    if (filepath instanceof URL) {
-      continue; // skip if already resolved
-    }
-    try {
-      config.tokens[i] = new URL(filepath, cwd);
-    } catch {
-      logger.error({ group: 'config', label: 'tokens', message: `Invalid URL ${filepath}` });
-    }
-  }
-}
-
-/** Normalize config.outDir */
-function normalizeOutDir({ config, cwd, logger }: { config: ConfigInit; logger: Logger; cwd: URL }) {
-  if (config.outDir instanceof URL) {
-    // noop
-  } else if (typeof config.outDir === 'undefined') {
-    config.outDir = new URL('./tokens/', cwd);
-  } else if (typeof config.outDir !== 'string') {
-    logger.error({
-      group: 'config',
-      label: 'outDir',
-      message: `Expected string, received ${JSON.stringify(config.outDir)}`,
-    });
-  } else {
-    config.outDir = new URL(config.outDir, cwd);
-    // always add trailing slash so URL treats it as a directory.
-    // do AFTER it has been normalized to POSIX paths with `href` (don’t use Node internals here! This may run in the browser)
-    config.outDir = new URL(config.outDir.href.replace(TRAILING_SLASH_RE, '/'));
-  }
-}
-
-/** Normalize config.plugins */
-function normalizePlugins({ config, logger }: { config: ConfigInit; logger: Logger }) {
-  if (typeof config.plugins === 'undefined') {
-    config.plugins = [];
-  }
-  if (!Array.isArray(config.plugins)) {
-    logger.error({
-      group: 'config',
-      label: 'plugins',
-      message: `Expected array of plugins, received ${JSON.stringify(config.plugins)}`,
-    });
-  }
-  config.plugins.push(coreLintPlugin());
-  for (let n = 0; n < config.plugins.length; n++) {
-    const plugin = config.plugins[n];
-    if (typeof plugin !== 'object') {
-      logger.error({
-        group: 'config',
-        label: `plugin[${n}]`,
-        message: `Expected output plugin, received ${JSON.stringify(plugin)}`,
-      });
-    } else if (!plugin.name) {
-      logger.error({ group: 'config', label: `plugin[${n}]`, message: `Missing "name"` });
-    }
-  }
-  // order plugins with "enforce"
-  config.plugins.sort((a, b) => {
-    if (a.enforce === 'pre' && b.enforce !== 'pre') {
-      return -1;
-    } else if (a.enforce === 'post' && b.enforce !== 'post') {
-      return 1;
-    }
-    return 0;
-  });
-}
-
-function normalizeLint({ config, logger }: { config: ConfigInit; logger: Logger }) {
-  if (config.lint !== undefined) {
-    if (config.lint === null || typeof config.lint !== 'object' || Array.isArray(config.lint)) {
-      logger.error({ group: 'config', label: 'lint', message: 'Must be an object' });
-    }
-    if (!config.lint.build) {
-      config.lint.build = { enabled: true };
-    }
-    if (config.lint.build.enabled !== undefined) {
-      if (typeof config.lint.build.enabled !== 'boolean') {
-        logger.error({
-          group: 'config',
-          label: 'lint › build › enabled',
-          message: `Expected boolean, received ${JSON.stringify(config.lint.build)}`,
-        });
-      }
-    } else {
-      config.lint.build.enabled = true;
-    }
-
-    if (config.lint.rules === undefined) {
-      config.lint.rules = { ...RECOMMENDED_CONFIG };
-    } else {
-      if (config.lint.rules === null || typeof config.lint.rules !== 'object' || Array.isArray(config.lint.rules)) {
-        logger.error({
-          group: 'config',
-          label: 'lint › rules',
-          message: `Expected object, received ${JSON.stringify(config.lint.rules)}`,
-        });
-        return;
-      }
-
-      const allRules = new Map<string, string>();
-      for (const plugin of config.plugins) {
-        if (typeof plugin.lint !== 'function') {
-          continue;
-        }
-        const pluginRules = plugin.lint();
-        if (!pluginRules || Array.isArray(pluginRules) || typeof pluginRules !== 'object') {
-          logger.error({
-            group: 'config',
-            label: `plugin › ${plugin.name}`,
-            message: `Expected object for lint() received ${JSON.stringify(pluginRules)}`,
-          });
-          continue;
-        }
-        for (const rule of Object.keys(pluginRules)) {
-          // Note: sometimes plugins will be loaded multiple times, in which case it’s expected
-          // they’re register rules again for lint(). Only throw an error if plugin A and plugin B’s
-          // rules conflict.
-          if (allRules.get(rule) && allRules.get(rule) !== plugin.name) {
-            logger.error({
-              group: 'config',
-              label: `plugin › ${plugin.name}`,
-              message: `Duplicate rule ${rule} already registered by plugin ${allRules.get(rule)}`,
-            });
-          }
-          allRules.set(rule, plugin.name);
-        }
-      }
-
-      for (const id of Object.keys(config.lint.rules)) {
-        if (!allRules.has(id)) {
-          logger.error({
-            group: 'config',
-            label: `lint › rule › ${id}`,
-            message: 'Unknown rule. Is the plugin installed?',
-          });
-        }
-
-        const value = config.lint.rules[id];
-        let severity: LintRuleSeverity = 'off';
-        let options: any = {};
-        if (typeof value === 'number' || typeof value === 'string') {
-          severity = value;
-        } else if (Array.isArray(value)) {
-          severity = value[0] as LintRuleSeverity;
-          options = value[1];
-        } else if (value !== undefined) {
-          logger.error({
-            group: 'config',
-            label: `lint › rule › ${id}`,
-            message: `Invalid eyntax. Expected \`string | number | Array\`, received ${JSON.stringify(value)}}`,
-          });
-        }
-        config.lint.rules[id] = [severity, options];
-        if (typeof severity === 'number') {
-          if (severity !== 0 && severity !== 1 && severity !== 2) {
-            logger.error({
-              group: 'config',
-              label: `lint › rule › ${id}`,
-              message: `Invalid number ${severity}. Specify 0 (off), 1 (warn), or 2 (error).`,
-            });
-          }
-          config.lint.rules[id]![0] = (['off', 'warn', 'error'] as const)[severity]!;
-        } else if (typeof severity === 'string') {
-          if (severity !== 'off' && severity !== 'warn' && severity !== 'error') {
-            logger.error({
-              group: 'config',
-              label: `lint › rule › ${id}`,
-              message: `Invalid string ${JSON.stringify(severity)}. Specify "off", "warn", or "error".`,
-            });
-          }
-        } else if (value !== null) {
-          logger.error({
-            group: 'config',
-            label: `lint › rule › ${id}`,
-            message: `Expected string or number, received ${JSON.stringify(value)}`,
-          });
-        }
-      }
-    }
-  } else {
-    config.lint = {
-      build: { enabled: true },
-      rules: { ...RECOMMENDED_CONFIG },
-    };
-  }
-}
-
-function normalizeIgnore({ config, logger }: { config: ConfigInit; logger: Logger }) {
-  if (!config.ignore) {
-    config.ignore = {} as typeof config.ignore;
-  }
-  config.ignore.tokens ??= [];
-  config.ignore.deprecated ??= false;
-  if (!Array.isArray(config.ignore.tokens) || config.ignore.tokens.some((x) => typeof x !== 'string')) {
-    logger.error({
-      group: 'config',
-      label: 'ignore › tokens',
-      message: `Expected array of strings, received ${JSON.stringify(config.ignore.tokens)}`,
-    });
-  }
-  if (typeof config.ignore.deprecated !== 'boolean') {
-    logger.error({
-      group: 'config',
-      label: 'ignore › deprecated',
-      message: `Expected boolean, received ${JSON.stringify(config.ignore.deprecated)}`,
-    });
-  }
-}
-
-/** Merge configs */
-export function mergeConfigs(a: Config, b: Config): Config {
-  return merge(a, b);
-}

package/src/index.ts

@@ -1,95 +0,0 @@
-export type {
-  AliasToken,
-  AliasValue,
-  BooleanToken,
-  BooleanTokenNormalized,
-  BooleanValue,
-  BorderToken,
-  BorderTokenNormalized,
-  BorderValue,
-  BorderValueNormalized,
-  ColorSpace,
-  ColorToken,
-  ColorTokenNormalized,
-  ColorValue,
-  ColorValueNormalized,
-  CubicBezierToken,
-  CubicBezierTokenNormalized,
-  CubicBezierValue,
-  CustomTransformOptions,
-  DimensionToken,
-  DimensionTokenNormalized,
-  DimensionValue,
-  DurationToken,
-  DurationTokenNormalized,
-  DurationValue,
-  FontFamilyToken,
-  FontFamilyTokenNormalized,
-  FontFamilyValue,
-  FontFamilyValueNormalized,
-  FontWeightToken,
-  FontWeightTokenNormalized,
-  FontWeightValue,
-  FontWeightValueNormalized,
-  GradientStop,
-  GradientStopNormalized,
-  GradientToken,
-  GradientTokenNormalized,
-  GradientValue,
-  GradientValueNormalized,
-  Group,
-  GroupCore,
-  GroupOrToken,
-  LinkToken,
-  LinkTokenNormalized,
-  LinkValue,
-  ModeMap,
-  NumberToken,
-  NumberTokenNormalized,
-  NumberValue,
-  ShadowToken,
-  ShadowTokenNormalized,
-  ShadowValue,
-  ShadowValueNormalized,
-  StringToken,
-  StringTokenNormalized,
-  StringValue,
-  StrokeStyleToken,
-  StrokeStyleTokenNormalized,
-  StrokeStyleValue,
-  StrokeStyleValueExpanded,
-  Token,
-  TokenCore,
-  TokenMode,
-  TokenNormalized,
-  TokenNormalizedCore,
-  TokenNormalizedSet,
-  TokensSet,
-  TransitionToken,
-  TransitionTokenNormalized,
-  TransitionValue,
-  TransitionValueNormalized,
-  TypographyToken,
-  TypographyTokenNormalized,
-  TypographyValue,
-  TypographyValueNormalized,
-} from '@terrazzo/token-tools';
-
-export * from './build/index.js';
-export { default as build } from './build/index.js';
-
-export * from './config.js';
-export { default as defineConfig } from './config.js';
-
-export * from './lint/index.js';
-export { default as lintRunner } from './lint/index.js';
-
-export * from './logger.js';
-export { default as Logger } from './logger.js';
-
-export * from './parse/index.js';
-export { default as parse } from './parse/index.js';
-
-export * from './resolver/index.js';
-
-export * from './types.js';