@terrazzo/parser 0.10.4 → 2.0.0-alpha.0

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

@@ -0,0 +1,123 @@
+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_DURATION = 'core/valid-duration';
+
+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;
+  /**
+   * Allow the use of unknown "unit" values
+   * @default false
+   */
+  unknownUnits?: boolean;
+}
+
+const rule: LintRule<
+  typeof ERROR_FORMAT | typeof ERROR_LEGACY | typeof ERROR_UNIT | typeof ERROR_VALUE | typeof ERROR_INVALID_PROP,
+  RuleValidDimension
+> = {
+  meta: {
+    messages: {
+      [ERROR_FORMAT]: 'Migrate to the new object format: { "value": 2, "unit": "ms" }.',
+      [ERROR_LEGACY]: 'Migrate to the new object format: { "value": 10, "unit": "px" }.',
+      [ERROR_INVALID_PROP]: 'Unknown property: {{ key }}.',
+      [ERROR_UNIT]: 'Unknown unit {{ unit }}. Expected "ms" or "s".',
+      [ERROR_VALUE]: 'Expected number, received {{ value }}.',
+    },
+    docs: {
+      description: 'Require duration tokens to follow the format',
+      url: docsLink(VALID_DURATION),
+    },
+  },
+  defaultOptions: {
+    legacyFormat: false,
+    unknownUnits: false,
+  },
+  create({ tokens, options, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue) {
+        continue;
+      }
+
+      switch (t.$type) {
+        case 'duration': {
+          validateDuration(t.originalValue.$value, {
+            node: getObjMember(t.source.node, '$value')!,
+            filename: t.source.filename,
+          });
+          break;
+        }
+        case 'transition': {
+          if (typeof t.originalValue.$value === 'object') {
+            const $valueNode = getObjMember(t.source.node, '$value');
+            for (const property of ['duration', 'delay'] as const) {
+              if (t.originalValue.$value[property] && !isAlias(t.originalValue.$value[property] as string)) {
+                validateDuration(t.originalValue.$value[property], {
+                  node: getObjMember($valueNode as momoa.ObjectNode, property)!,
+                  filename: t.source.filename,
+                });
+              }
+            }
+          }
+          break;
+        }
+      }
+
+      function validateDuration(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.unknownUnits && !['ms', 's'].includes(unit)) {
+            report({
+              messageId: ERROR_UNIT,
+              data: { unit },
+              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_FORMAT, node, filename });
+        } else {
+          report({ messageId: ERROR_FORMAT, data: { value }, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/valid-font-family.ts

@@ -0,0 +1,68 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember, getObjMembers } from '@terrazzo/json-schema-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_FONT_FAMILY = 'core/valid-font-family';
+
+const ERROR = 'ERROR';
+
+const rule: LintRule<typeof ERROR> = {
+  meta: {
+    messages: {
+      [ERROR]: 'Must be a string, or array of strings.',
+    },
+    docs: {
+      description: 'Require fontFamily tokens to follow the format.',
+      url: docsLink(VALID_FONT_FAMILY),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue) {
+        continue;
+      }
+
+      switch (t.$type) {
+        case 'fontFamily': {
+          validateFontFamily(t.originalValue.$value, {
+            node: getObjMember(t.source.node, '$value') as momoa.ArrayNode,
+            filename: t.source.filename,
+          });
+          break;
+        }
+        case 'typography': {
+          if (typeof t.originalValue.$value === 'object' && t.originalValue.$value.fontFamily) {
+            if (t.partialAliasOf?.fontFamily) {
+              continue;
+            }
+            const $value = getObjMember(t.source.node, '$value');
+            const properties = getObjMembers($value as momoa.ObjectNode);
+            validateFontFamily(t.originalValue.$value.fontFamily, {
+              node: properties.fontFamily as momoa.ArrayNode,
+              filename: t.source.filename,
+            });
+          }
+          break;
+        }
+      }
+
+      function validateFontFamily(value: unknown, { node, filename }: { node: momoa.ArrayNode; filename?: string }) {
+        if (typeof value === 'string') {
+          if (!value) {
+            report({ messageId: ERROR, node, filename });
+          }
+        } else if (Array.isArray(value)) {
+          if (!value.every((v) => v && typeof v === 'string')) {
+            report({ messageId: ERROR, node, filename });
+          }
+        } else {
+          report({ messageId: ERROR, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/valid-font-weight.ts

@@ -0,0 +1,89 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember, getObjMembers } from '@terrazzo/json-schema-tools';
+import { FONT_WEIGHTS } from '@terrazzo/token-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_FONT_WEIGHT = 'core/valid-font-weight';
+
+const ERROR = 'ERROR';
+const ERROR_STYLE = 'ERROR_STYLE';
+
+export interface RuleFontWeightOptions {
+  /**
+   * Enforce either:
+   * - "numbers" (0-999)
+   * - "names" ("light", "medium", "bold", etc.)
+   */
+  style?: 'numbers' | 'names';
+}
+
+const rule: LintRule<typeof ERROR | typeof ERROR_STYLE, RuleFontWeightOptions> = {
+  meta: {
+    messages: {
+      [ERROR]: `Must either be a valid number (0 - 999) or a valid font weight: ${new Intl.ListFormat(undefined, { type: 'disjunction' }).format(Object.keys(FONT_WEIGHTS))}.`,
+      [ERROR_STYLE]: 'Expected style {{ style }}, received {{ value }}.',
+    },
+    docs: {
+      description: 'Require number tokens to follow the format.',
+      url: docsLink(VALID_FONT_WEIGHT),
+    },
+  },
+  defaultOptions: {
+    style: undefined,
+  },
+  create({ tokens, options, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue) {
+        continue;
+      }
+
+      switch (t.$type) {
+        case 'fontWeight': {
+          validateFontWeight(t.originalValue.$value, {
+            node: getObjMember(t.source.node, '$value') as momoa.StringNode,
+            filename: t.source.filename,
+          });
+          break;
+        }
+        case 'typography': {
+          if (typeof t.originalValue.$value === 'object' && t.originalValue.$value.fontWeight) {
+            if (t.partialAliasOf?.fontWeight) {
+              continue;
+            }
+            const $value = getObjMember(t.source.node, '$value');
+            const properties = getObjMembers($value as momoa.ObjectNode);
+            validateFontWeight(t.originalValue.$value.fontWeight, {
+              node: properties.fontWeight as momoa.StringNode,
+              filename: t.source.filename,
+            });
+          }
+          break;
+        }
+      }
+
+      function validateFontWeight(
+        value: unknown,
+        { node, filename }: { node: momoa.StringNode | momoa.NumberNode; filename?: string },
+      ) {
+        if (typeof value === 'string') {
+          if (options.style === 'numbers') {
+            report({ messageId: ERROR_STYLE, data: { style: 'numbers', value }, node, filename });
+          } else if (!(value in FONT_WEIGHTS)) {
+            report({ messageId: ERROR, node, filename });
+          }
+        } else if (typeof value === 'number') {
+          if (options.style === 'names') {
+            report({ messageId: ERROR_STYLE, data: { style: 'names', value }, node, filename });
+          } else if (!(value >= 0 && value < 1000)) {
+            report({ messageId: ERROR, node, filename });
+          }
+        } else {
+          report({ messageId: ERROR, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

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

@@ -0,0 +1,79 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember } from '@terrazzo/json-schema-tools';
+import { GRADIENT_REQUIRED_STOP_PROPERTIES, isAlias } from '@terrazzo/token-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_GRADIENT = 'core/valid-gradient';
+
+const ERROR_MISSING = 'ERROR_MISSING';
+const ERROR_POSITION = 'ERROR_POSITION';
+const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
+
+const rule: LintRule<typeof ERROR_MISSING | typeof ERROR_POSITION | typeof ERROR_INVALID_PROP> = {
+  meta: {
+    messages: {
+      [ERROR_MISSING]: 'Must be an array of { color, position } objects.',
+      [ERROR_POSITION]: 'Expected number 0-1, received {{ value }}.',
+      [ERROR_INVALID_PROP]: 'Unknown property {{ key }}.',
+    },
+    docs: {
+      description: 'Require gradient tokens to follow the format.',
+      url: docsLink(VALID_GRADIENT),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue || t.$type !== 'gradient') {
+        continue;
+      }
+
+      validateGradient(t.originalValue.$value, {
+        node: getObjMember(t.source.node, '$value') as momoa.ArrayNode,
+        filename: t.source.filename,
+      });
+
+      function validateGradient(value: unknown, { node, filename }: { node: momoa.ArrayNode; filename?: string }) {
+        if (Array.isArray(value)) {
+          for (let i = 0; i < value.length; i++) {
+            const stop = value[i]!;
+            if (!stop || typeof stop !== 'object') {
+              report({ messageId: ERROR_MISSING, node, filename });
+              continue;
+            }
+            for (const property of GRADIENT_REQUIRED_STOP_PROPERTIES) {
+              if (!(property in stop)) {
+                report({ messageId: ERROR_MISSING, node: node.elements[i], filename });
+              }
+            }
+            for (const key of Object.keys(stop)) {
+              if (
+                !GRADIENT_REQUIRED_STOP_PROPERTIES.includes(key as (typeof GRADIENT_REQUIRED_STOP_PROPERTIES)[number])
+              ) {
+                report({
+                  messageId: ERROR_INVALID_PROP,
+                  data: { key: JSON.stringify(key) },
+                  node: node.elements[i],
+                  filename,
+                });
+              }
+            }
+            if ('position' in stop && typeof stop.position !== 'number' && !isAlias(stop.position as string)) {
+              report({
+                messageId: ERROR_POSITION,
+                data: { value: stop.position },
+                node: getObjMember(node.elements[i]!.value as momoa.ObjectNode, 'position'),
+                filename,
+              });
+            }
+          }
+        } else {
+          report({ messageId: ERROR_MISSING, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/valid-link.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_LINK = 'core/valid-link';
+
+const ERROR = 'ERROR';
+
+const rule: LintRule<typeof ERROR, {}> = {
+  meta: {
+    messages: {
+      [ERROR]: 'Must be a string.',
+    },
+    docs: {
+      description: 'Require link tokens to follow the Terrazzo extension.',
+      url: docsLink(VALID_LINK),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue || t.$type !== 'link') {
+        continue;
+      }
+
+      validateLink(t.originalValue.$value, {
+        node: getObjMember(t.source.node, '$value') as momoa.StringNode,
+        filename: t.source.filename,
+      });
+
+      function validateLink(value: unknown, { node, filename }: { node: momoa.StringNode; filename?: string }) {
+        if (!value || typeof value !== 'string') {
+          report({ messageId: ERROR, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

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

@@ -0,0 +1,63 @@
+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_NUMBER = 'core/valid-number';
+
+const ERROR_NAN = 'ERROR_NAN';
+
+const rule: LintRule<typeof ERROR_NAN> = {
+  meta: {
+    messages: {
+      [ERROR_NAN]: 'Must be a number.',
+    },
+    docs: {
+      description: 'Require number tokens to follow the format.',
+      url: docsLink(VALID_NUMBER),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue) {
+        continue;
+      }
+
+      switch (t.$type) {
+        case 'number': {
+          validateNumber(t.originalValue.$value, {
+            node: getObjMember(t.source.node, '$value') as momoa.NumberNode,
+            filename: t.source.filename,
+          });
+          break;
+        }
+        // Note: gradient not needed, validated in gradient
+        case 'typography': {
+          const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
+          if (typeof t.originalValue.$value === 'object') {
+            if (
+              t.originalValue.$value.lineHeight &&
+              !isAlias(t.originalValue.$value.lineHeight as string) &&
+              typeof t.originalValue.$value.lineHeight !== 'object'
+            ) {
+              validateNumber(t.originalValue.$value.lineHeight, {
+                node: getObjMember($valueNode, 'lineHeight') as momoa.NumberNode,
+                filename: t.source.filename,
+              });
+            }
+          }
+        }
+      }
+
+      function validateNumber(value: unknown, { node, filename }: { node: momoa.NumberNode; filename?: string }) {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+          report({ messageId: ERROR_NAN, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

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

@@ -0,0 +1,67 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember } from '@terrazzo/json-schema-tools';
+import { SHADOW_REQUIRED_PROPERTIES } from '@terrazzo/token-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_SHADOW = 'core/valid-shadow';
+
+const ERROR = 'ERROR';
+const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
+
+const rule: LintRule<typeof ERROR | typeof ERROR_INVALID_PROP> = {
+  meta: {
+    messages: {
+      [ERROR]: `Missing required properties: ${new Intl.ListFormat(undefined, { type: 'conjunction' }).format(SHADOW_REQUIRED_PROPERTIES)}.`,
+      [ERROR_INVALID_PROP]: 'Unknown property {{ key }}.',
+    },
+    docs: {
+      description: 'Require shadow tokens to follow the format.',
+      url: docsLink(VALID_SHADOW),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue || t.$type !== 'shadow') {
+        continue;
+      }
+
+      validateShadow(t.originalValue.$value, {
+        node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
+        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 validateShadow(
+        value: unknown,
+        { node, filename }: { node: momoa.ObjectNode | momoa.ArrayNode; filename?: string },
+      ) {
+        const wrappedValue = Array.isArray(value) ? value : [value];
+        for (let i = 0; i < wrappedValue.length; i++) {
+          if (
+            !wrappedValue[i] ||
+            typeof wrappedValue[i] !== 'object' ||
+            !SHADOW_REQUIRED_PROPERTIES.every((property) => property in wrappedValue[i])
+          ) {
+            report({ messageId: ERROR, node, filename });
+          } else {
+            for (const key of Object.keys(wrappedValue[i])) {
+              if (![...SHADOW_REQUIRED_PROPERTIES, 'inset'].includes(key)) {
+                report({
+                  messageId: ERROR_INVALID_PROP,
+                  data: { key: JSON.stringify(key) },
+                  node: getObjMember(node.type === 'Array' ? (node.elements[i]!.value as momoa.ObjectNode) : node, key),
+                  filename,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/valid-string.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_STRING = 'core/valid-string';
+
+const ERROR = 'ERROR';
+
+const rule: LintRule<typeof ERROR> = {
+  meta: {
+    messages: {
+      [ERROR]: 'Must be a string.',
+    },
+    docs: {
+      description: 'Require string tokens to follow the Terrazzo extension.',
+      url: docsLink(VALID_STRING),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue || t.$type !== 'string') {
+        continue;
+      }
+
+      validateString(t.originalValue.$value, {
+        node: getObjMember(t.source.node, '$value') as momoa.StringNode,
+        filename: t.source.filename,
+      });
+
+      function validateString(value: unknown, { node, filename }: { node: momoa.StringNode; filename?: string }) {
+        if (typeof value !== 'string') {
+          report({ messageId: ERROR, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/valid-stroke-style.ts

@@ -0,0 +1,104 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember } from '@terrazzo/json-schema-tools';
+import {
+  isAlias,
+  STROKE_STYLE_LINE_CAP_VALUES,
+  STROKE_STYLE_OBJECT_REQUIRED_PROPERTIES,
+  STROKE_STYLE_STRING_VALUES,
+  TRANSITION_REQUIRED_PROPERTIES,
+} from '@terrazzo/token-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_STROKE_STYLE = 'core/valid-stroke-style';
+
+const ERROR_STR = 'ERROR_STR';
+const ERROR_OBJ = 'ERROR_OBJ';
+const ERROR_LINE_CAP = 'ERROR_LINE_CAP';
+const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
+
+const rule: LintRule<typeof ERROR_STR | typeof ERROR_OBJ | typeof ERROR_LINE_CAP | typeof ERROR_INVALID_PROP> = {
+  meta: {
+    messages: {
+      [ERROR_STR]: `Value most be one of ${new Intl.ListFormat(undefined, { type: 'disjunction' }).format(STROKE_STYLE_STRING_VALUES)}.`,
+      [ERROR_OBJ]: `Missing required properties: ${new Intl.ListFormat(undefined, { type: 'conjunction' }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
+      [ERROR_LINE_CAP]: `lineCap must be one of ${new Intl.ListFormat(undefined, { type: 'disjunction' }).format(STROKE_STYLE_LINE_CAP_VALUES)}.`,
+      [ERROR_INVALID_PROP]: 'Unknown property: {{ key }}.',
+    },
+    docs: {
+      description: 'Require strokeStyle tokens to follow the format.',
+      url: docsLink(VALID_STROKE_STYLE),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue) {
+        continue;
+      }
+
+      switch (t.$type) {
+        case 'strokeStyle': {
+          validateStrokeStyle(t.originalValue.$value, {
+            node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
+            filename: t.source.filename,
+          });
+          break;
+        }
+        case 'border': {
+          if (t.originalValue.$value && typeof t.originalValue.$value === 'object') {
+            const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
+            if (t.originalValue.$value.style) {
+              validateStrokeStyle(t.originalValue.$value.style, {
+                node: getObjMember($valueNode, 'style') as momoa.ObjectNode,
+                filename: t.source.filename,
+              });
+            }
+          }
+          break;
+        }
+      }
+
+      // 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 validateStrokeStyle(
+        value: unknown,
+        { node, filename }: { node: momoa.StringNode | momoa.ObjectNode; filename?: string },
+      ) {
+        if (typeof value === 'string') {
+          if (
+            !isAlias(value) &&
+            !STROKE_STYLE_STRING_VALUES.includes(value as (typeof STROKE_STYLE_STRING_VALUES)[number])
+          ) {
+            report({ messageId: ERROR_STR, node, filename });
+            return;
+          }
+        } else if (value && typeof value === 'object') {
+          if (!STROKE_STYLE_OBJECT_REQUIRED_PROPERTIES.every((property) => property in value)) {
+            report({ messageId: ERROR_OBJ, node, filename });
+          }
+          if (!Array.isArray((value as any).dashArray)) {
+            report({ messageId: ERROR_OBJ, node: getObjMember(node as momoa.ObjectNode, 'dashArray'), filename });
+          }
+          if (!STROKE_STYLE_LINE_CAP_VALUES.includes((value as any).lineCap)) {
+            report({ messageId: ERROR_OBJ, node: getObjMember(node as momoa.ObjectNode, 'lineCap'), filename });
+          }
+          for (const key of Object.keys(value)) {
+            if (!['dashArray', 'lineCap'].includes(key)) {
+              report({
+                messageId: ERROR_INVALID_PROP,
+                data: { key: JSON.stringify(key) },
+                node: getObjMember(node as momoa.ObjectNode, key),
+                filename,
+              });
+            }
+          }
+        } else {
+          report({ messageId: ERROR_OBJ, node, filename });
+        }
+      }
+    }
+  },
+};
+
+export default rule;