@terrazzo/parser 0.10.3 → 2.0.0-alpha.0

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

@@ -5,12 +5,16 @@ import { docsLink } from '../lib/docs.js';
 export const REQUIRED_TYPOGRAPHY_PROPERTIES = 'core/required-typography-properties';
 
 export interface RuleRequiredTypographyPropertiesOptions {
-  /** Required typography properties */
+  /**
+   * 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: {
@@ -18,7 +22,9 @@ const rule: LintRule<never, RuleRequiredTypographyPropertiesOptions> = {
       url: docsLink(REQUIRED_TYPOGRAPHY_PROPERTIES),
     },
   },
-  defaultOptions: { properties: [] },
+  defaultOptions: {
+    properties: ['fontFamily', 'fontSize', 'fontWeight', 'letterSpacing', 'lineHeight'],
+  },
   create({ tokens, options, report }) {
     if (!options) {
       return;
@@ -45,7 +51,11 @@ const rule: LintRule<never, RuleRequiredTypographyPropertiesOptions> = {
 
       for (const p of options.properties) {
         if (!t.partialAliasOf?.[p] && !(p in t.$value)) {
-          report({ message: `${t.id} missing required typographic property "${p}"`, node: t.source.node });
+          report({
+            message: `This rule is deprecated. Use core/valid-typography. Missing required typographic property "${p}"`,
+            node: t.source.node,
+            filename: t.source.filename,
+          });
         }
       }
     }

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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,57 @@
+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(undefined, { 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

@@ -0,0 +1,265 @@
+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(undefined, { 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

@@ -0,0 +1,83 @@
+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;

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

@@ -0,0 +1,199 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember } 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_DIMENSION = 'core/valid-dimension';
+
+const ERROR_FORMAT = 'ERROR_FORMAT';
+const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
+const ERROR_LEGACY = 'ERROR_LEGACY';
+const ERROR_UNIT = 'ERROR_UNIT';
+const ERROR_VALUE = 'ERROR_VALUE';
+
+export interface RuleValidDimension {
+  /**
+   * Allow the use of unknown "unit" values
+   * @default false
+   */
+  legacyFormat?: boolean;
+  /**
+   * Only allow the following units.
+   * @default ["px", "rem"]
+   */
+  allowedUnits?: string[];
+}
+
+const rule: LintRule<
+  typeof ERROR_FORMAT | typeof ERROR_LEGACY | typeof ERROR_UNIT | typeof ERROR_VALUE | typeof ERROR_INVALID_PROP,
+  RuleValidDimension
+> = {
+  meta: {
+    messages: {
+      [ERROR_FORMAT]: 'Invalid dimension: {{ value }}. Expected object with "value" and "unit".',
+      [ERROR_LEGACY]: 'Migrate to the new object format: { "value": 10, "unit": "px" }.',
+      [ERROR_UNIT]: 'Unit {{ unit }} not allowed. Expected {{ allowed }}.',
+      [ERROR_INVALID_PROP]: 'Unknown property {{ key }}.',
+      [ERROR_VALUE]: 'Expected number, received {{ value }}.',
+    },
+    docs: {
+      description: 'Require dimension tokens to follow the format',
+      url: docsLink(VALID_DIMENSION),
+    },
+  },
+  defaultOptions: {
+    legacyFormat: false,
+    allowedUnits: ['px', 'em', 'rem'],
+  },
+  create({ tokens, options, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue) {
+        continue;
+      }
+
+      switch (t.$type) {
+        case 'dimension': {
+          validateDimension(t.originalValue.$value, {
+            node: getObjMember(t.source.node, '$value'),
+            filename: t.source.filename,
+          });
+          break;
+        }
+        case 'strokeStyle': {
+          if (typeof t.originalValue.$value === 'object' && Array.isArray(t.originalValue.$value.dashArray)) {
+            const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
+            const dashArray = getObjMember($valueNode, 'dashArray') as momoa.ArrayNode;
+            for (let i = 0; i < t.originalValue.$value.dashArray.length; i++) {
+              if (isAlias(t.originalValue.$value.dashArray[i] as string)) {
+                continue;
+              }
+              validateDimension(t.originalValue.$value.dashArray[i], {
+                node: dashArray.elements[i]!.value,
+                filename: t.source.filename,
+              });
+            }
+          }
+          break;
+        }
+        case 'border': {
+          const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
+          if (typeof t.originalValue.$value === 'object') {
+            if (t.originalValue.$value.width && !isAlias(t.originalValue.$value.width as string)) {
+              validateDimension(t.originalValue.$value.width, {
+                node: getObjMember($valueNode, 'width'),
+                filename: t.source.filename,
+              });
+            }
+            if (
+              typeof t.originalValue.$value.style === 'object' &&
+              Array.isArray(t.originalValue.$value.style.dashArray)
+            ) {
+              const style = getObjMember($valueNode, 'style') as momoa.ObjectNode;
+              const dashArray = getObjMember(style, 'dashArray') as momoa.ArrayNode;
+              for (let i = 0; i < t.originalValue.$value.style.dashArray.length; i++) {
+                if (isAlias(t.originalValue.$value.style.dashArray[i] as string)) {
+                  continue;
+                }
+                validateDimension(t.originalValue.$value.style.dashArray[i], {
+                  node: dashArray.elements[i]!.value,
+                  filename: t.source.filename,
+                });
+              }
+            }
+          }
+          break;
+        }
+        case 'shadow': {
+          if (t.originalValue.$value && typeof t.originalValue.$value === 'object') {
+            const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode | momoa.ArrayNode;
+            const valueArray = Array.isArray(t.originalValue.$value)
+              ? t.originalValue.$value
+              : [t.originalValue.$value];
+            for (let i = 0; i < valueArray.length; i++) {
+              const node =
+                $valueNode.type === 'Array' ? ($valueNode.elements[i]!.value as momoa.ObjectNode) : $valueNode;
+              for (const property of ['offsetX', 'offsetY', 'blur', 'spread'] as const) {
+                if (isAlias(valueArray[i]![property] as string)) {
+                  continue;
+                }
+                validateDimension(valueArray[i]![property], {
+                  node: getObjMember(node, property),
+                  filename: t.source.filename,
+                });
+              }
+            }
+          }
+          break;
+        }
+        case 'typography': {
+          const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
+          if (typeof t.originalValue.$value === 'object') {
+            for (const property of ['fontSize', 'lineHeight', 'letterSpacing'] as const) {
+              if (property in t.originalValue.$value) {
+                if (
+                  isAlias(t.originalValue.$value[property] as string) ||
+                  // special case: lineHeight may be a number
+                  (property === 'lineHeight' && typeof t.originalValue.$value[property] === 'number')
+                ) {
+                  continue;
+                }
+                validateDimension(t.originalValue.$value[property], {
+                  node: getObjMember($valueNode, property),
+                  filename: t.source.filename,
+                });
+              }
+            }
+          }
+          break;
+        }
+      }
+
+      function validateDimension(value: unknown, { node, filename }: { node?: momoa.AnyNode; filename?: string }) {
+        if (value && typeof value === 'object') {
+          for (const key of Object.keys(value)) {
+            if (!['value', 'unit'].includes(key)) {
+              report({
+                messageId: ERROR_INVALID_PROP,
+                data: { key: JSON.stringify(key) },
+                node: getObjMember(node as momoa.ObjectNode, key) ?? node,
+                filename,
+              });
+            }
+          }
+
+          const { unit, value: numValue } = value as Record<string, any>;
+          if (!('value' in value || 'unit' in value)) {
+            report({ messageId: ERROR_FORMAT, data: { value }, node, filename });
+            return;
+          }
+          if (!options.allowedUnits!.includes(unit)) {
+            report({
+              messageId: ERROR_UNIT,
+              data: {
+                unit,
+                allowed: new Intl.ListFormat('en-us', { type: 'disjunction' }).format(options.allowedUnits!),
+              },
+              node: getObjMember(node as momoa.ObjectNode, 'unit') ?? node,
+              filename,
+            });
+          }
+          if (!Number.isFinite(numValue)) {
+            report({
+              messageId: ERROR_VALUE,
+              data: { value },
+              node: getObjMember(node as momoa.ObjectNode, 'value') ?? node,
+              filename,
+            });
+          }
+        } else if (typeof value === 'string' && !options.legacyFormat) {
+          report({ messageId: ERROR_LEGACY, node, filename });
+        } else {
+          report({ messageId: ERROR_FORMAT, data: { value }, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;