@adobe/design-system-registry 0.0.0-layout-20260209174611

package/registry/variants.json

@@ -0,0 +1,176 @@
+{
+  "$schema": "https://opensource.adobe.com/spectrum-design-data/schemas/registry-value.json",
+  "type": "variant",
+  "description": "Color and style variants used across components",
+  "values": [
+    {
+      "id": "accent",
+      "label": "Accent",
+      "description": "Primary accent color variant",
+      "category": "emphasis",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "negative",
+      "label": "Negative",
+      "description": "Destructive or negative action variant",
+      "category": "semantic",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "primary",
+      "label": "Primary",
+      "description": "Primary emphasis variant",
+      "category": "emphasis",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "secondary",
+      "label": "Secondary",
+      "description": "Secondary emphasis variant",
+      "category": "emphasis",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "positive",
+      "label": "Positive",
+      "description": "Affirmative or positive action variant",
+      "category": "semantic",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "notice",
+      "label": "Notice",
+      "description": "Notice or attention variant",
+      "category": "semantic",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "informative",
+      "label": "Informative",
+      "description": "Informational variant",
+      "category": "semantic",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "neutral",
+      "label": "Neutral",
+      "description": "Neutral variant",
+      "category": "semantic",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "gray",
+      "label": "Gray",
+      "description": "Gray color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "red",
+      "label": "Red",
+      "description": "Red color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "orange",
+      "label": "Orange",
+      "description": "Orange color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "yellow",
+      "label": "Yellow",
+      "description": "Yellow color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "chartreuse",
+      "label": "Chartreuse",
+      "description": "Chartreuse color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "celery",
+      "label": "Celery",
+      "description": "Celery color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "green",
+      "label": "Green",
+      "description": "Green color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "seafoam",
+      "label": "Seafoam",
+      "description": "Seafoam color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "cyan",
+      "label": "Cyan",
+      "description": "Cyan color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "blue",
+      "label": "Blue",
+      "description": "Blue color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "indigo",
+      "label": "Indigo",
+      "description": "Indigo color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "purple",
+      "label": "Purple",
+      "description": "Purple color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "fuchsia",
+      "label": "Fuchsia",
+      "description": "Fuchsia color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "magenta",
+      "label": "Magenta",
+      "description": "Magenta color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "pink",
+      "label": "Pink",
+      "description": "Pink color variant",
+      "category": "color",
+      "usedIn": ["component-schemas"]
+    },
+    {
+      "id": "over-background",
+      "label": "Over Background",
+      "aliases": ["over background"],
+      "description": "Designed to be used over backgrounds",
+      "category": "context",
+      "usedIn": ["component-schemas"]
+    }
+  ]
+}

package/schemas/platform-extension.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://opensource.adobe.com/spectrum-design-data/schemas/platform-extension.json",
+  "title": "Platform Extension",
+  "description": "Schema for platform-specific terminology extensions",
+  "type": "object",
+  "required": ["platform", "extends", "extensions"],
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "platform": {
+      "type": "string",
+      "description": "The platform this extension is for (e.g., iOS, Android, Web Components, Qt)"
+    },
+    "platformVersion": {
+      "type": "string",
+      "description": "Optional platform version or framework version"
+    },
+    "description": {
+      "type": "string",
+      "description": "Description of what this extension provides"
+    },
+    "extends": {
+      "type": "string",
+      "description": "Which registry this extends (sizes, states, variants, etc.)"
+    },
+    "extensions": {
+      "type": "array",
+      "description": "Array of term extensions",
+      "items": {
+        "$ref": "#/$defs/extension"
+      }
+    }
+  },
+  "$defs": {
+    "extension": {
+      "type": "object",
+      "required": ["termId"],
+      "properties": {
+        "termId": {
+          "type": "string",
+          "description": "The ID of the term being extended (must exist in the base registry)"
+        },
+        "platformTerm": {
+          "type": "string",
+          "description": "Platform-specific term or name"
+        },
+        "platformAliases": {
+          "type": "array",
+          "description": "Platform-specific aliases",
+          "items": {
+            "type": "string"
+          }
+        },
+        "notes": {
+          "type": "string",
+          "description": "Platform-specific implementation notes"
+        },
+        "reference": {
+          "type": "string",
+          "description": "Platform documentation reference or API name"
+        },
+        "codeExample": {
+          "type": "string",
+          "description": "Code example showing platform usage"
+        },
+        "differences": {
+          "type": "array",
+          "description": "Key differences from the base term",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

package/schemas/registry-value.json

@@ -0,0 +1,230 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://opensource.adobe.com/spectrum-design-data/schemas/registry-value.json",
+  "title": "Registry Value",
+  "description": "Schema for design system registry value entries",
+  "type": "object",
+  "required": ["type", "description", "values"],
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "type": {
+      "type": "string",
+      "description": "The type of registry (size, state, variant, etc.)"
+    },
+    "description": {
+      "type": "string",
+      "description": "Description of what this registry contains"
+    },
+    "allowCustom": {
+      "type": "boolean",
+      "description": "Whether custom values are allowed beyond the registry"
+    },
+    "customPattern": {
+      "type": "string",
+      "description": "Regex pattern for validating custom values"
+    },
+    "values": {
+      "type": "array",
+      "description": "Array of registry values",
+      "items": {
+        "$ref": "#/$defs/value"
+      }
+    }
+  },
+  "$defs": {
+    "value": {
+      "type": "object",
+      "required": ["id", "label"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier for this value"
+        },
+        "label": {
+          "type": "string",
+          "description": "Human-readable label"
+        },
+        "aliases": {
+          "type": "array",
+          "description": "Alternative names or spellings",
+          "items": {
+            "type": "string"
+          }
+        },
+        "description": {
+          "type": "string",
+          "description": "Detailed description of this value"
+        },
+        "default": {
+          "type": "boolean",
+          "description": "Whether this is the default value"
+        },
+        "deprecated": {
+          "type": "boolean",
+          "description": "Whether this value is deprecated"
+        },
+        "usedIn": {
+          "type": "array",
+          "description": "Where this value is used (tokens, component-schemas, etc.)",
+          "items": {
+            "type": "string"
+          }
+        },
+        "category": {
+          "type": "string",
+          "description": "Category or grouping for this value"
+        },
+        "value": {
+          "type": ["string", "number", "boolean"],
+          "description": "Actual value (if different from id)"
+        },
+        "documentationUrl": {
+          "type": "string",
+          "format": "uri",
+          "description": "URL to documentation"
+        },
+        "definition": {
+          "type": "object",
+          "description": "Structured definition following Spectrum naming methodology",
+          "properties": {
+            "superordinate": {
+              "type": "string",
+              "description": "The higher-level category or class this term belongs to"
+            },
+            "description": {
+              "type": "string",
+              "description": "Core definition explaining what it is and how it differs"
+            },
+            "essentialCharacteristics": {
+              "type": "array",
+              "description": "Key characteristics that distinguish this term",
+              "items": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "platforms": {
+          "type": "object",
+          "description": "Platform-specific terminology and notes",
+          "patternProperties": {
+            ".*": {
+              "type": "object",
+              "properties": {
+                "term": {
+                  "type": "string",
+                  "description": "Platform-specific term or name"
+                },
+                "notes": {
+                  "type": "string",
+                  "description": "Platform-specific implementation notes"
+                },
+                "reference": {
+                  "type": "string",
+                  "description": "Platform documentation reference"
+                }
+              }
+            }
+          }
+        },
+        "terminology": {
+          "type": "object",
+          "description": "Terminology metadata and classification",
+          "properties": {
+            "conceptType": {
+              "type": "string",
+              "enum": ["word", "term", "name", "concept"],
+              "description": "Classification per Spectrum naming guide"
+            },
+            "namingRationale": {
+              "type": "string",
+              "description": "Why this name was chosen"
+            },
+            "alternatives": {
+              "type": "array",
+              "description": "Alternative terms considered but not used",
+              "items": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "sources": {
+          "type": "array",
+          "description": "References to source documentation",
+          "items": {
+            "type": "object",
+            "required": ["type"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "wiki",
+                  "industry-standard",
+                  "platform-standard",
+                  "internal-doc",
+                  "research"
+                ],
+                "description": "Type of source"
+              },
+              "url": {
+                "type": "string",
+                "format": "uri",
+                "description": "URL to source"
+              },
+              "reference": {
+                "type": "string",
+                "description": "Text reference or citation"
+              },
+              "date": {
+                "type": "string",
+                "format": "date",
+                "description": "Date of source or last update"
+              }
+            }
+          }
+        },
+        "governance": {
+          "type": "object",
+          "description": "Governance and ownership metadata",
+          "properties": {
+            "owner": {
+              "type": "string",
+              "description": "Team or person responsible for this term"
+            },
+            "reviewDate": {
+              "type": "string",
+              "format": "date",
+              "description": "Last review date"
+            },
+            "nextReviewDate": {
+              "type": "string",
+              "format": "date",
+              "description": "Scheduled next review date"
+            },
+            "status": {
+              "type": "string",
+              "enum": ["draft", "review", "approved", "deprecated"],
+              "description": "Current status of this term"
+            },
+            "replacedBy": {
+              "type": "string",
+              "description": "If deprecated, the term that replaces this one"
+            }
+          }
+        },
+        "relatedTerms": {
+          "type": "array",
+          "description": "Related or cross-referenced terms",
+          "items": {
+            "type": "string",
+            "description": "ID of related term"
+          }
+        }
+      }
+    }
+  }
+}

package/scripts/validate-registry.js

@@ -0,0 +1,134 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const registryDir = join(__dirname, "..", "registry");
+const schemaPath = join(__dirname, "..", "schemas", "registry-value.json");
+
+const ajv = new Ajv({ strict: false, allErrors: true });
+addFormats(ajv);
+
+const schema = JSON.parse(readFileSync(schemaPath, "utf-8"));
+const validate = ajv.compile(schema);
+
+let hasErrors = false;
+
+console.log("🔍 Validating design system registry...\n");
+
+// Get all registry files
+const registryFiles = readdirSync(registryDir).filter((f) =>
+  f.endsWith(".json"),
+);
+
+for (const file of registryFiles) {
+  const filePath = join(registryDir, file);
+  const registry = JSON.parse(readFileSync(filePath, "utf-8"));
+
+  console.log(`📄 Validating ${file}...`);
+
+  // Validate against JSON schema
+  const valid = validate(registry);
+  if (!valid) {
+    console.error(`  ❌ Schema validation failed:`);
+    validate.errors.forEach((err) => {
+      console.error(`     ${err.instancePath}: ${err.message}`);
+    });
+    hasErrors = true;
+    continue;
+  }
+
+  // Check for duplicate IDs
+  const ids = new Set();
+  const duplicateIds = [];
+  for (const value of registry.values) {
+    if (ids.has(value.id)) {
+      duplicateIds.push(value.id);
+    }
+    ids.add(value.id);
+  }
+
+  if (duplicateIds.length > 0) {
+    console.error(`  ❌ Duplicate IDs found: ${duplicateIds.join(", ")}`);
+    hasErrors = true;
+  }
+
+  // Check for duplicate aliases
+  const aliases = new Map();
+  for (const value of registry.values) {
+    if (value.aliases) {
+      for (const alias of value.aliases) {
+        if (aliases.has(alias)) {
+          console.error(
+            `  ❌ Duplicate alias "${alias}" found in ${value.id} (already used by ${aliases.get(alias)})`,
+          );
+          hasErrors = true;
+        }
+        aliases.set(alias, value.id);
+      }
+    }
+  }
+
+  // Check that only one value has default: true
+  const defaults = registry.values.filter((v) => v.default === true);
+  if (defaults.length > 1) {
+    console.error(
+      `  ❌ Multiple default values found: ${defaults.map((d) => d.id).join(", ")}`,
+    );
+    hasErrors = true;
+  }
+
+  // Check that relatedTerms reference valid IDs
+  for (const value of registry.values) {
+    if (value.relatedTerms) {
+      for (const relatedId of value.relatedTerms) {
+        if (!ids.has(relatedId)) {
+          console.error(
+            `  ❌ Invalid relatedTerm "${relatedId}" in ${value.id} (term does not exist)`,
+          );
+          hasErrors = true;
+        }
+      }
+    }
+  }
+
+  // Check that governance.replacedBy references valid IDs
+  for (const value of registry.values) {
+    if (value.governance?.replacedBy) {
+      if (!ids.has(value.governance.replacedBy)) {
+        console.error(
+          `  ❌ Invalid governance.replacedBy "${value.governance.replacedBy}" in ${value.id} (term does not exist)`,
+        );
+        hasErrors = true;
+      }
+    }
+  }
+
+  if (!hasErrors) {
+    console.log(`  ✅ Valid (${registry.values.length} values)`);
+  }
+  console.log("");
+}
+
+if (hasErrors) {
+  console.error("❌ Validation failed with errors\n");
+  process.exit(1);
+} else {
+  console.log("✅ All registry files validated successfully\n");
+  process.exit(0);
+}