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

package/src/lint/plugin-core/rules/required-typography-properties.ts

@@ -1,65 +0,0 @@
-import wcmatch from 'wildcard-match';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const REQUIRED_TYPOGRAPHY_PROPERTIES = 'core/required-typography-properties';
-
-export interface RuleRequiredTypographyPropertiesOptions {
-  /**
-   * Required typography properties.
-   * @default ["fontFamily", "fontWeight", "fontSize", "letterSpacing", "lineHeight"]
-   */
-  properties: string[];
-  /** Token globs to ignore */
-  ignore?: string[];
-}
-
-/** @deprecated Use core/valid-typography instead */
-const rule: LintRule<never, RuleRequiredTypographyPropertiesOptions> = {
-  meta: {
-    docs: {
-      description: 'Enforce typography tokens have required properties.',
-      url: docsLink(REQUIRED_TYPOGRAPHY_PROPERTIES),
-    },
-  },
-  defaultOptions: {
-    properties: ['fontFamily', 'fontSize', 'fontWeight', 'letterSpacing', 'lineHeight'],
-  },
-  create({ tokens, options, report }) {
-    if (!options) {
-      return;
-    }
-
-    if (!options.properties.length) {
-      throw new Error(`"properties" can’t be empty`);
-    }
-
-    const shouldIgnore = options.ignore ? wcmatch(options.ignore) : null;
-
-    for (const t of Object.values(tokens)) {
-      if (shouldIgnore?.(t.id)) {
-        continue;
-      }
-
-      if (t.$type !== 'typography') {
-        continue;
-      }
-
-      if (t.aliasOf) {
-        continue;
-      }
-
-      for (const p of options.properties) {
-        if (!t.partialAliasOf?.[p] && !(p in t.$value)) {
-          report({
-            message: `This rule is deprecated. Use core/valid-typography. Missing required typographic property "${p}"`,
-            node: t.source.node,
-            filename: t.source.filename,
-          });
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-boolean.ts

@@ -1,41 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_BOOLEAN = 'core/valid-boolean';
-
-const ERROR = 'ERROR';
-
-const rule: LintRule<typeof ERROR, {}> = {
-  meta: {
-    messages: {
-      [ERROR]: 'Must be a boolean.',
-    },
-    docs: {
-      description: 'Require boolean tokens to follow the Terrazzo extension.',
-      url: docsLink(VALID_BOOLEAN),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue || t.$type !== 'boolean') {
-        continue;
-      }
-
-      validateBoolean(t.originalValue.$value, {
-        node: getObjMember(t.source.node, '$value'),
-        filename: t.source.filename,
-      });
-
-      function validateBoolean(value: unknown, { node, filename }: { node?: momoa.AnyNode; filename?: string }) {
-        if (typeof value !== 'boolean') {
-          report({ messageId: ERROR, filename, node });
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-border.ts

@@ -1,57 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import { BORDER_REQUIRED_PROPERTIES } from '@terrazzo/token-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_BORDER = 'core/valid-border';
-
-const ERROR = 'ERROR';
-const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
-
-const rule: LintRule<typeof ERROR | typeof ERROR_INVALID_PROP, {}> = {
-  meta: {
-    messages: {
-      [ERROR]: `Border token missing required properties: ${new Intl.ListFormat('en-us', { type: 'conjunction' }).format(BORDER_REQUIRED_PROPERTIES)}.`,
-      [ERROR_INVALID_PROP]: 'Unknown property: {{ key }}.',
-    },
-    docs: {
-      description: 'Require border tokens to follow the format.',
-      url: docsLink(VALID_BORDER),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue || t.$type !== 'border') {
-        continue;
-      }
-
-      validateBorder(t.originalValue.$value, {
-        node: getObjMember(t.source.node, '$value'),
-        filename: t.source.filename,
-      });
-    }
-
-    // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
-    // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
-    function validateBorder(value: unknown, { node, filename }: { node?: momoa.AnyNode; filename?: string }) {
-      if (!value || typeof value !== 'object' || !BORDER_REQUIRED_PROPERTIES.every((property) => property in value)) {
-        report({ messageId: ERROR, filename, node });
-      } else {
-        for (const key of Object.keys(value)) {
-          if (!BORDER_REQUIRED_PROPERTIES.includes(key as (typeof BORDER_REQUIRED_PROPERTIES)[number])) {
-            report({
-              messageId: ERROR_INVALID_PROP,
-              data: { key: JSON.stringify(key) },
-              node: getObjMember(node as momoa.ObjectNode, key) ?? node,
-              filename,
-            });
-          }
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-color.ts

@@ -1,265 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import {
-  type BorderValue,
-  COLORSPACE,
-  type ColorSpaceDefinition,
-  type ColorValueNormalized,
-  type GradientStopNormalized,
-  type GradientValueNormalized,
-  isAlias,
-  parseColor,
-  type ShadowValue,
-} from '@terrazzo/token-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_COLOR = 'core/valid-color';
-
-const ERROR_ALPHA = 'ERROR_ALPHA';
-const ERROR_INVALID_COLOR = 'ERROR_INVALID_COLOR';
-const ERROR_INVALID_COLOR_SPACE = 'ERROR_INVALID_COLOR_SPACE';
-const ERROR_INVALID_COMPONENT_LENGTH = 'ERROR_INVALID_COMPONENT_LENGTH';
-const ERROR_INVALID_HEX8 = 'ERROR_INVALID_HEX8';
-const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
-const ERROR_MISSING_COMPONENTS = 'ERROR_MISSING_COMPONENTS';
-const ERROR_OBJ_FORMAT = 'ERROR_OBJ_FORMAT';
-const ERROR_OUT_OF_RANGE = 'ERROR_OUT_OF_RANGE';
-
-export interface RuleValidColorOptions {
-  /**
-   * Allow the legacy format of only a string sRGB hex code
-   * @default false
-   */
-  legacyFormat?: boolean;
-  /**
-   * Allow colors to be defined out of the expected ranges.
-   * @default false
-   */
-  ignoreRanges?: boolean;
-}
-
-const rule: LintRule<
-  | typeof ERROR_ALPHA
-  | typeof ERROR_INVALID_COLOR
-  | typeof ERROR_INVALID_COLOR_SPACE
-  | typeof ERROR_INVALID_COMPONENT_LENGTH
-  | typeof ERROR_INVALID_HEX8
-  | typeof ERROR_INVALID_PROP
-  | typeof ERROR_MISSING_COMPONENTS
-  | typeof ERROR_OBJ_FORMAT
-  | typeof ERROR_OUT_OF_RANGE,
-  RuleValidColorOptions
-> = {
-  meta: {
-    messages: {
-      [ERROR_ALPHA]: `Alpha {{ alpha }} not in range 0 – 1.`,
-      [ERROR_INVALID_COLOR_SPACE]: `Invalid color space: {{ colorSpace }}. Expected ${new Intl.ListFormat('en-us', { type: 'disjunction' }).format(Object.keys(COLORSPACE))}`,
-      [ERROR_INVALID_COLOR]: `Could not parse color {{ color }}.`,
-      [ERROR_INVALID_COMPONENT_LENGTH]: 'Expected {{ expected }} components, received {{ got }}.',
-      [ERROR_INVALID_HEX8]: `Hex value can’t be semi-transparent.`,
-      [ERROR_INVALID_PROP]: `Unknown property {{ key }}.`,
-      [ERROR_MISSING_COMPONENTS]: 'Expected components to be array of numbers, received {{ got }}.',
-      [ERROR_OBJ_FORMAT]:
-        'Migrate to the new object format, e.g. "#ff0000" → { "colorSpace": "srgb", "components": [1, 0, 0] } }',
-      [ERROR_OUT_OF_RANGE]: `Invalid range for color space {{ colorSpace }}. Expected {{ range }}.`,
-    },
-    docs: {
-      description: 'Require color tokens to follow the format.',
-      url: docsLink(VALID_COLOR),
-    },
-  },
-  defaultOptions: {
-    legacyFormat: false,
-    ignoreRanges: false,
-  },
-  create({ tokens, options, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue) {
-        continue;
-      }
-
-      switch (t.$type) {
-        case 'color': {
-          validateColor(t.originalValue.$value, {
-            node: getObjMember(t.source.node, '$value'),
-            filename: t.source.filename,
-          });
-          break;
-        }
-        case 'border': {
-          if ((t.originalValue.$value as any).color && !isAlias((t.originalValue.$value as any).color)) {
-            validateColor((t.originalValue.$value as BorderValue).color, {
-              node: getObjMember(getObjMember(t.source.node, '$value') as momoa.ObjectNode, 'color'),
-              filename: t.source.filename,
-            });
-          }
-          break;
-        }
-        case 'gradient': {
-          const $valueNode = getObjMember(t.source.node, '$value') as momoa.ArrayNode;
-          for (let i = 0; i < (t.originalValue.$value as GradientValueNormalized).length; i++) {
-            const stop = t.originalValue.$value[i] as GradientStopNormalized;
-            if (!stop.color || isAlias(stop.color as any)) {
-              continue;
-            }
-            validateColor(stop.color, {
-              node: getObjMember($valueNode.elements[i]!.value as momoa.ObjectNode, 'color'),
-              filename: t.source.filename,
-            });
-          }
-          break;
-        }
-        case 'shadow': {
-          const $value = (
-            Array.isArray(t.originalValue.$value) ? t.originalValue.$value : [t.originalValue.$value]
-          ) as ShadowValue[];
-          const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode | momoa.ArrayNode;
-          for (let i = 0; i < $value.length; i++) {
-            const layer = $value[i]!;
-            if (!layer.color || isAlias(layer.color as any)) {
-              continue;
-            }
-            validateColor(layer.color, {
-              node:
-                $valueNode.type === 'Object'
-                  ? getObjMember($valueNode, 'color')
-                  : getObjMember($valueNode.elements[i]!.value as momoa.ObjectNode, 'color'),
-              filename: t.source.filename,
-            });
-          }
-          break;
-        }
-      }
-
-      function validateColor(value: unknown, { node, filename }: { node?: momoa.AnyNode; filename?: string }) {
-        if (!value) {
-          report({ messageId: ERROR_INVALID_COLOR, data: { color: JSON.stringify(value) }, node, filename });
-        } else if (typeof value === 'object') {
-          for (const key of Object.keys(value)) {
-            if (!['colorSpace', 'components', 'channels' /* TODO: remove */, 'hex', 'alpha'].includes(key)) {
-              report({
-                messageId: ERROR_INVALID_PROP,
-                data: { key: JSON.stringify(key) },
-                node: getObjMember(node as momoa.ObjectNode, key) ?? node,
-                filename,
-              });
-            }
-          }
-
-          // Color space
-          const colorSpace =
-            'colorSpace' in value && typeof value.colorSpace === 'string' ? value.colorSpace : undefined;
-          const csData = (COLORSPACE as Record<string, ColorSpaceDefinition>)[colorSpace!] || undefined;
-          if (!('colorSpace' in value) || !csData) {
-            report({
-              messageId: ERROR_INVALID_COLOR_SPACE,
-              data: { colorSpace },
-              node: getObjMember(node as momoa.ObjectNode, 'colorSpace') ?? node,
-              filename,
-            });
-            return;
-          }
-
-          // Component ranges
-          const components = 'components' in value ? value.components : undefined;
-          if (Array.isArray(components)) {
-            if (csData?.ranges && components?.length === csData.ranges.length) {
-              for (let i = 0; i < components.length; i++) {
-                if (
-                  !Number.isFinite(components[i]) ||
-                  components[i]! < csData.ranges[i]![0] ||
-                  components[i]! > csData.ranges[i]![1]
-                ) {
-                  // special case for any hue-based components: allow null
-                  if (
-                    !(colorSpace === 'hsl' && components[0]! === null) &&
-                    !(colorSpace === 'hwb' && components[0]! === null) &&
-                    !(colorSpace === 'lch' && components[2]! === null) &&
-                    !(colorSpace === 'oklch' && components[2]! === null)
-                  ) {
-                    report({
-                      messageId: ERROR_OUT_OF_RANGE,
-                      data: { colorSpace, range: `[${csData.ranges.map((r) => `${r[0]}–${r[1]}`).join(', ')}]` },
-                      node: getObjMember(node as momoa.ObjectNode, 'components') ?? node,
-                      filename,
-                    });
-                  }
-                }
-              }
-            } else {
-              report({
-                messageId: ERROR_INVALID_COMPONENT_LENGTH,
-                data: { expected: csData?.ranges.length, got: (components as number[] | undefined)?.length ?? 0 },
-                node: getObjMember(node as momoa.ObjectNode, 'components') ?? node,
-                filename,
-              });
-            }
-          } else {
-            report({
-              messageId: ERROR_MISSING_COMPONENTS,
-              data: { got: JSON.stringify(components) },
-              node: getObjMember(node as momoa.ObjectNode, 'components') ?? node,
-              filename,
-            });
-          }
-
-          // Alpha
-          const alpha = 'alpha' in value ? value.alpha : undefined;
-          if (alpha !== undefined && (typeof alpha !== 'number' || alpha < 0 || alpha > 1)) {
-            report({
-              messageId: ERROR_ALPHA,
-              data: { alpha },
-              node: getObjMember(node as momoa.ObjectNode, 'alpha') ?? node,
-              filename,
-            });
-          }
-
-          // Hex
-          const hex = 'hex' in value ? value.hex : undefined;
-          if (hex) {
-            let color: ColorValueNormalized;
-            try {
-              color = parseColor(hex as string);
-            } catch {
-              report({
-                messageId: ERROR_INVALID_COLOR,
-                data: { color: hex },
-                node: getObjMember(node as momoa.ObjectNode, 'hex') ?? node,
-                filename,
-              });
-              return;
-            }
-            // since we’re only parsing hex, this should always have alpha: 1
-            if (color.alpha !== 1) {
-              report({
-                messageId: ERROR_INVALID_HEX8,
-                data: { color: hex },
-                node: getObjMember(node as momoa.ObjectNode, 'hex') ?? node,
-                filename,
-              });
-            }
-          }
-        } else if (typeof value === 'string') {
-          if (isAlias(value)) {
-            return;
-          }
-          if (!options.legacyFormat) {
-            report({ messageId: ERROR_OBJ_FORMAT, data: { color: JSON.stringify(value) }, node, filename });
-          } else {
-            // Legacy format
-            try {
-              parseColor(value as string);
-            } catch {
-              report({ messageId: ERROR_INVALID_COLOR, data: { color: JSON.stringify(value) }, node, filename });
-            }
-          }
-        } else {
-          report({ messageId: ERROR_INVALID_COLOR, node, filename });
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-cubic-bezier.ts

@@ -1,83 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember, isPure$ref } from '@terrazzo/json-schema-tools';
-import { isAlias } from '@terrazzo/token-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_CUBIC_BEZIER = 'core/valid-cubic-bezier';
-
-const ERROR = 'ERROR';
-const ERROR_X = 'ERROR_X';
-const ERROR_Y = 'ERROR_Y';
-
-const rule: LintRule<typeof ERROR | typeof ERROR_X | typeof ERROR_Y> = {
-  meta: {
-    messages: {
-      [ERROR]: 'Expected [number, number, number, number].',
-      [ERROR_X]: 'x values must be between 0-1.',
-      [ERROR_Y]: 'y values must be a valid number.',
-    },
-    docs: {
-      description: 'Require cubicBezier tokens to follow the format.',
-      url: docsLink(VALID_CUBIC_BEZIER),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue) {
-        continue;
-      }
-
-      switch (t.$type) {
-        case 'cubicBezier': {
-          validateCubicBezier(t.originalValue.$value, {
-            node: getObjMember(t.source.node, '$value') as momoa.ArrayNode,
-            filename: t.source.filename,
-          });
-          break;
-        }
-        case 'transition': {
-          if (
-            typeof t.originalValue.$value === 'object' &&
-            t.originalValue.$value.timingFunction &&
-            !isAlias(t.originalValue.$value.timingFunction as string)
-          ) {
-            const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
-            validateCubicBezier(t.originalValue.$value.timingFunction, {
-              node: getObjMember($valueNode, 'timingFunction') as momoa.ArrayNode,
-              filename: t.source.filename,
-            });
-          }
-        }
-      }
-
-      function validateCubicBezier(value: unknown, { node, filename }: { node: momoa.ArrayNode; filename?: string }) {
-        if (Array.isArray(value) && value.length === 4) {
-          // validate x values
-          for (const pos of [0, 2]) {
-            if (isAlias(value[pos]) || isPure$ref(value[pos])) {
-              continue;
-            }
-            if (!(value[pos] >= 0 && value[pos] <= 1)) {
-              report({ messageId: ERROR_X, node: (node as momoa.ArrayNode).elements[pos], filename });
-            }
-          }
-          // validate y values
-          for (const pos of [1, 3]) {
-            if (isAlias(value[pos]) || isPure$ref(value[pos])) {
-              continue;
-            }
-            if (typeof value[pos] !== 'number') {
-              report({ messageId: ERROR_Y, node: (node as momoa.ArrayNode).elements[pos], filename });
-            }
-          }
-        } else {
-          report({ messageId: ERROR, node, filename });
-        }
-      }
-    }
-  },
-};
-
-export default rule;