@sebgroup/green-core 2.37.3 → 2.37.4-rc.20260326093456728

package/bin/context-cli/framework.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 const DOCS_FRAMEWORK_CANONICAL = [
   "angular",
   "react",

package/bin/context-cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import { McpError } from "../mcp-server/errors.js";
 import {
   handleGetComponentDocs,

package/bin/context-cli/migrate/engine.js

@@ -1,4 +1,4 @@
-import "../../../chunks/chunk.QU3DSPNU.js";
+import "../../../chunks/chunk.CAV4X6PU.js";
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import { extname, join, relative, resolve } from "node:path";
 const DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -21,7 +21,8 @@ async function* walkDir(dir, skipDirs) {
   }
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      if (skipDirs.has(entry.name)) continue;
+      if (skipDirs.has(entry.name))
+        continue;
       yield* walkDir(join(dir, entry.name), skipDirs);
     } else if (entry.isFile()) {
       yield join(dir, entry.name);
@@ -43,7 +44,8 @@ async function runMigrations(options) {
   const resolvedBase = resolve(basePath);
   const skipDirs = new Set(DEFAULT_SKIP_DIRS);
   if (extraSkip) {
-    for (const dir of extraSkip) skipDirs.add(dir);
+    for (const dir of extraSkip)
+      skipDirs.add(dir);
   }
   const allExtensions = /* @__PURE__ */ new Set();
   for (const unit of units) {
@@ -76,7 +78,8 @@ async function runMigrations(options) {
         continue;
       }
       const matches = unit.detect(filePath, content);
-      if (matches.length === 0) continue;
+      if (matches.length === 0)
+        continue;
       const relFile = relative(resolvedBase, filePath).replace(/\\/g, "/");
       for (const m of matches) {
         m.file = relFile;

package/bin/context-cli/migrate/index.js

@@ -1,4 +1,4 @@
-import "../../../chunks/chunk.QU3DSPNU.js";
+import "../../../chunks/chunk.CAV4X6PU.js";
 import { runMigrations } from "./engine.js";
 import { getMigrationUnits } from "./registry.js";
 const PROGRAM_NAME = "green-core-context";

package/bin/context-cli/migrate/registry.js

@@ -1,13 +1,16 @@
-import "../../../chunks/chunk.QU3DSPNU.js";
+import "../../../chunks/chunk.CAV4X6PU.js";
 import { readdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_UNITS_DIR = join(__dirname, "units");
 function isUnitFile(name) {
-  if (name.endsWith(".d.ts")) return false;
-  if (name.endsWith(".test.ts") || name.endsWith(".test.js")) return false;
-  if (name.endsWith(".spec.ts") || name.endsWith(".spec.js")) return false;
+  if (name.endsWith(".d.ts"))
+    return false;
+  if (name.endsWith(".test.ts") || name.endsWith(".test.js"))
+    return false;
+  if (name.endsWith(".spec.ts") || name.endsWith(".spec.js"))
+    return false;
   return name.endsWith(".ts") || name.endsWith(".js");
 }
 async function discoverMigrationUnits(basePath) {
@@ -20,9 +23,11 @@ async function discoverMigrationUnits(basePath) {
     return results;
   }
   for (const entry of topEntries) {
-    if (!entry.isDirectory()) continue;
+    if (!entry.isDirectory())
+      continue;
     const major = Number(entry.name);
-    if (Number.isNaN(major)) continue;
+    if (Number.isNaN(major))
+      continue;
     const majorDir = join(unitsDir, entry.name);
     let files;
     try {
@@ -31,7 +36,8 @@ async function discoverMigrationUnits(basePath) {
       continue;
     }
     for (const file of files) {
-      if (!file.isFile() || !isUnitFile(file.name)) continue;
+      if (!file.isFile() || !isUnitFile(file.name))
+        continue;
       try {
         const moduleUrl = pathToFileURL(join(majorDir, file.name)).href;
         const mod = await import(moduleUrl);

package/bin/context-cli/migrate/units/0/example.js

@@ -1,4 +1,4 @@
-import "../../../../../chunks/chunk.QU3DSPNU.js";
+import "../../../../../chunks/chunk.CAV4X6PU.js";
 const VARIANTS = [
   // ----- HTML attribute (plain HTML, web component, Angular template) -----
   {
@@ -81,7 +81,8 @@ function detectVariants(filePath, content, variants) {
 function applyVariants(content, variants) {
   let result = content;
   for (const variant of variants) {
-    if (!variant.safe) continue;
+    if (!variant.safe)
+      continue;
     variant.pattern.lastIndex = 0;
     result = result.replace(variant.pattern, variant.replace);
   }

package/bin/context-cli/migrate/units/3/card-variant-renames.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Migration unit: Legacy card variant renames for 3.0
+ *
+ * Rewrites deprecated card variants to the canonical variant API:
+ * - primary   -> neutral-01
+ * - secondary -> neutral-02 + outline
+ * - tertiary  -> neutral-02
+ *
+ * Covered syntaxes:
+ * - Web components: <gds-card>, <gds-card-linked>
+ * - React wrappers: <Core.GdsCard>, <Core.GdsCardLinked>, <GdsCard>, <GdsCardLinked>
+ * - Angular bindings in tags: [variant]="'secondary'"
+ *
+ * @module migrate/units/3/card-variant-renames
+ */
+import type { MigrationUnit } from '../../types.js';
+export declare const unit: MigrationUnit;

package/bin/context-cli/migrate/units/3/card-variant-renames.js

@@ -0,0 +1,158 @@
+import "../../../../../chunks/chunk.CAV4X6PU.js";
+const DEFAULT_LINE = 1;
+const CARD_TAG_REGEX = /<(gds-card-linked|gds-card|Core\.GdsCardLinked|Core\.GdsCard|GdsCardLinked|GdsCard)\b[\s\S]*?(?:\/?>)/g;
+const VARIANT_ATTRIBUTE_REGEX = /\bvariant\s*=\s*(["'])(primary|secondary|tertiary)\1/g;
+const VARIANT_JSX_EXPRESSION_REGEX = /\bvariant\s*=\s*\{\s*(["'])(primary|secondary|tertiary)\1\s*\}/g;
+const VARIANT_ANGULAR_DOUBLE_OUTER_REGEX = /\[variant\]\s*=\s*"['"](primary|secondary|tertiary)['"]"/g;
+const VARIANT_ANGULAR_SINGLE_OUTER_REGEX = /\[variant\]\s*=\s*'["]?(primary|secondary|tertiary)["]?'/g;
+const OUTLINE_PRESENT_REGEX = /(?:\?outline\b|\?outlined\b|\[outline\]|\[outlined\]|\boutline\b|\boutlined\b)/;
+function isLegacyCardVariant(value) {
+  return value === "primary" || value === "secondary" || value === "tertiary";
+}
+function mapVariant(value) {
+  if (value === "primary")
+    return "neutral-01";
+  return "neutral-02";
+}
+function messageForVariant(value) {
+  if (value === "secondary") {
+    return "Replace card variant secondary with neutral-02 and add outline.";
+  }
+  if (value === "tertiary") {
+    return "Replace card variant tertiary with neutral-02 (tertiary removed).";
+  }
+  return "Replace card variant primary with neutral-01.";
+}
+function isReactTag(tagName) {
+  return tagName.startsWith("Core.") || tagName === "GdsCard" || tagName === "GdsCardLinked";
+}
+function addOutlineIfMissing(tag, tagName) {
+  if (OUTLINE_PRESENT_REGEX.test(tag)) {
+    return tag;
+  }
+  const outlineProp = isReactTag(tagName) ? "outline={true}" : "outline";
+  return tag.replace(/\s*\/?>$/, (closing) => ` ${outlineProp}${closing}`);
+}
+function lineNumberAt(content, index) {
+  if (index <= 0)
+    return DEFAULT_LINE;
+  let lines = DEFAULT_LINE;
+  for (let i = 0; i < index; i++) {
+    if (content.charCodeAt(i) === 10)
+      lines++;
+  }
+  return lines;
+}
+function collectVariants(tagContent) {
+  const variants = [];
+  const pushMatches = (regex, getVariant) => {
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(tagContent)) !== null) {
+      const variant = getVariant(match);
+      if (!isLegacyCardVariant(variant))
+        continue;
+      variants.push({
+        index: match.index,
+        fullMatch: match[0],
+        variant
+      });
+    }
+  };
+  pushMatches(VARIANT_ATTRIBUTE_REGEX, (match) => match[2]);
+  pushMatches(VARIANT_JSX_EXPRESSION_REGEX, (match) => match[2]);
+  pushMatches(VARIANT_ANGULAR_DOUBLE_OUTER_REGEX, (match) => match[1]);
+  pushMatches(VARIANT_ANGULAR_SINGLE_OUTER_REGEX, (match) => match[1]);
+  return variants;
+}
+function transformTag(tagName, originalTag) {
+  let result = originalTag;
+  let needsOutline = false;
+  result = result.replace(
+    VARIANT_ATTRIBUTE_REGEX,
+    (_full, quote, variant) => {
+      if (variant === "secondary")
+        needsOutline = true;
+      return `variant=${quote}${mapVariant(variant)}${quote}`;
+    }
+  );
+  result = result.replace(
+    VARIANT_JSX_EXPRESSION_REGEX,
+    (_full, quote, variant) => {
+      if (variant === "secondary")
+        needsOutline = true;
+      return `variant={${quote}${mapVariant(variant)}${quote}}`;
+    }
+  );
+  result = result.replace(
+    VARIANT_ANGULAR_DOUBLE_OUTER_REGEX,
+    (_full, variant) => {
+      if (variant === "secondary")
+        needsOutline = true;
+      return `[variant]="'${mapVariant(variant)}'"`;
+    }
+  );
+  result = result.replace(
+    VARIANT_ANGULAR_SINGLE_OUTER_REGEX,
+    (_full, variant) => {
+      if (variant === "secondary")
+        needsOutline = true;
+      return `[variant]="'${mapVariant(variant)}'"`;
+    }
+  );
+  if (needsOutline) {
+    result = addOutlineIfMissing(result, tagName);
+  }
+  return result;
+}
+function detect(filePath, content) {
+  const matches = [];
+  CARD_TAG_REGEX.lastIndex = 0;
+  let tagMatch;
+  while ((tagMatch = CARD_TAG_REGEX.exec(content)) !== null) {
+    const tagContent = tagMatch[0];
+    const tagStart = tagMatch.index;
+    const variantMatches = collectVariants(tagContent);
+    for (const variantMatch of variantMatches) {
+      matches.push({
+        file: filePath,
+        line: lineNumberAt(content, tagStart + variantMatch.index),
+        match: variantMatch.fullMatch,
+        message: messageForVariant(variantMatch.variant)
+      });
+    }
+  }
+  return matches;
+}
+function apply(_filePath, content) {
+  CARD_TAG_REGEX.lastIndex = 0;
+  const result = content.replace(
+    CARD_TAG_REGEX,
+    (fullMatch, tagName) => transformTag(tagName, fullMatch)
+  );
+  return result !== content ? result : null;
+}
+const unit = {
+  id: "card-variant-renames",
+  enabled: true,
+  summary: "Replace legacy card variants (primary/secondary/tertiary) with neutral variants and outline behavior",
+  exampleBefore: [
+    '<gds-card variant="primary"></gds-card>',
+    '<gds-card variant="secondary"></gds-card>',
+    '<gds-card variant="tertiary"></gds-card>',
+    '<Core.GdsCard variant="secondary" />'
+  ].join("\n"),
+  exampleAfter: [
+    '<gds-card variant="neutral-01"></gds-card>',
+    '<gds-card variant="neutral-02" outline></gds-card>',
+    '<gds-card variant="neutral-02"></gds-card>',
+    '<Core.GdsCard variant="neutral-02" outline={true} />'
+  ].join("\n"),
+  fileExtensions: [".html", ".ts", ".tsx", ".js", ".jsx", ".md", ".mdx"],
+  safe: true,
+  detect,
+  apply
+};
+export {
+  unit
+};

package/bin/context-cli/migrate/units/3/color-token-renames.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Migration unit: Color token renames for 3.0
+ *
+ * Applies deterministic token renames and flags deleted/legacy tokens for
+ * manual review. This migration is designed for **consumers** of the Green
+ * Design System — it works in any tech stack (CSS, SCSS, HTML, Angular,
+ * React, plain JS/TS) and does not reference internal library paths.
+ *
+ * Migration behavior
+ * - Full CSS custom property renames are applied automatically, including
+ *   the l3-neutral-01 ↔ l3-neutral-03 swap (handled in a single pass so
+ *   the two values do not collide).
+ * - Shorthand color attribute values used in React, Angular, and Web
+ *   Component templates are auto-migrated when the assignment is clearly
+ *   color-related (e.g. `color="subtle-01"` → `color="neutral-02"`).
+ * - Deleted and legacy tokens are flagged for manual review.
+ *
+ * @module migrate/units/3/color-token-renames
+ */
+import type { MigrationUnit } from '../../types.js';
+export declare const unit: MigrationUnit;

package/bin/context-cli/migrate/units/3/color-token-renames.js

@@ -0,0 +1,209 @@
+import "../../../../../chunks/chunk.CAV4X6PU.js";
+const RENAMES = [
+  // l1
+  ["--gds-sys-color-l1-inversed", "--gds-sys-color-l1-neutral-03"],
+  // l3 – note: 01 and 03 have swapped in 3.0
+  ["--gds-sys-color-l3-neutral-01", "--gds-sys-color-l3-neutral-03"],
+  ["--gds-sys-color-l3-neutral-03", "--gds-sys-color-l3-neutral-01"],
+  ["--gds-sys-color-l3-brand-03", "--gds-sys-color-l3-brand-02-2"],
+  // content
+  ["--gds-sys-color-content-inversed", "--gds-sys-color-content-neutral-05"],
+  // border
+  ["--gds-sys-color-border-interactive", "--gds-sys-color-border-neutral-01"],
+  ["--gds-sys-color-border-subtle-01", "--gds-sys-color-border-neutral-02"],
+  ["--gds-sys-color-border-subtle-02", "--gds-sys-color-border-neutral-03"],
+  ["--gds-sys-color-border-strong", "--gds-sys-color-border-neutral-04"],
+  ["--gds-sys-color-border-inverse", "--gds-sys-color-border-neutral-05"]
+];
+const SHORTHAND_RENAMES = [
+  ["inversed", "neutral-05"],
+  ["interactive", "neutral-01"],
+  ["subtle-01", "neutral-02"],
+  ["subtle-02", "neutral-03"],
+  ["strong", "neutral-04"],
+  ["inverse", "neutral-05"]
+];
+const SHORTHAND_TOKEN_NAMES = SHORTHAND_RENAMES.map(
+  ([oldToken]) => oldToken
+).sort((a, b) => b.length - a.length);
+const SHORTHAND_TOKEN_REGEX = new RegExp(
+  `(?<!--gds-sys-color-)(${SHORTHAND_TOKEN_NAMES.map((token) => escapeRegex(token)).join("|")})(?![a-z0-9-])`,
+  "g"
+);
+const DELETED = [
+  "--gds-sys-color-l3-neutral-04",
+  "--gds-sys-color-l3-neutral-05",
+  "--gds-sys-color-l3-disabled-02",
+  "--gds-sys-color-l3-disabled-03",
+  "--gds-sys-color-content-disabled-02"
+];
+const LEGACY_MANUAL_REVIEW = [
+  "--gds-sys-color-dark-red-2",
+  "--gds-sys-color-blue"
+];
+const RENAME_MAP = new Map(RENAMES);
+const SHORTHAND_RENAME_MAP = new Map(SHORTHAND_RENAMES);
+const DELETED_SET = new Set(DELETED);
+const LEGACY_SET = new Set(LEGACY_MANUAL_REVIEW);
+const DETECT_TOKENS = [
+  ...RENAMES.map(([oldToken]) => oldToken),
+  ...DELETED,
+  ...LEGACY_MANUAL_REVIEW
+];
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const TOKEN_REGEX = new RegExp(
+  DETECT_TOKENS.sort((a, b) => b.length - a.length).map((token) => escapeRegex(token)).join("|"),
+  "g"
+);
+const RENAME_REGEX = new RegExp(
+  RENAMES.map(([old]) => old).sort((a, b) => b.length - a.length).map((t) => escapeRegex(t)).join("|"),
+  "g"
+);
+const QUOTED_STRING_REGEX = /(["'`])((?:\\.|(?!\1).)*)\1/g;
+const COLOR_CONTEXT_REGEX = /(?:\b(?:color|border-color|borderColor|background-color|backgroundColor|text-color|textColor|icon-color|iconColor)\b|\[(?:color|border-color|borderColor|background-color|backgroundColor|text-color|textColor|icon-color|iconColor)\])\s*(?:=|:)\s*$/i;
+const SET_ATTRIBUTE_CONTEXT_REGEX = /setAttribute\(\s*["'`](?:color|border-color|borderColor|background-color|backgroundColor|text-color|textColor|icon-color|iconColor)["'`]\s*,\s*$/i;
+function isShorthandExpressionContext(line, quoteStartIndex) {
+  const before = line.slice(Math.max(0, quoteStartIndex - 180), quoteStartIndex);
+  return COLOR_CONTEXT_REGEX.test(before) || SET_ATTRIBUTE_CONTEXT_REGEX.test(before);
+}
+function detectShorthandExpressionMatches(filePath, line, lineNumber) {
+  const matches = [];
+  QUOTED_STRING_REGEX.lastIndex = 0;
+  let quotedMatch;
+  while ((quotedMatch = QUOTED_STRING_REGEX.exec(line)) !== null) {
+    const quoteStartIndex = quotedMatch.index;
+    if (!isShorthandExpressionContext(line, quoteStartIndex)) {
+      continue;
+    }
+    const quotedValue = quotedMatch[2];
+    if (quotedValue.includes("--gds-sys-color-")) {
+      continue;
+    }
+    SHORTHAND_TOKEN_REGEX.lastIndex = 0;
+    let tokenMatch;
+    while ((tokenMatch = SHORTHAND_TOKEN_REGEX.exec(quotedValue)) !== null) {
+      const token = tokenMatch[1];
+      const renamed = SHORTHAND_RENAME_MAP.get(token);
+      if (!renamed)
+        continue;
+      matches.push({
+        file: filePath,
+        line: lineNumber,
+        match: token,
+        message: `Rename shorthand ${token} to ${renamed} (3.0 color token rename).`
+      });
+    }
+  }
+  return matches;
+}
+function replaceShorthandExpressionsInLine(line) {
+  QUOTED_STRING_REGEX.lastIndex = 0;
+  return line.replace(
+    QUOTED_STRING_REGEX,
+    (fullMatch, quote, quotedValue, offset) => {
+      if (!isShorthandExpressionContext(line, offset)) {
+        return fullMatch;
+      }
+      if (quotedValue.includes("--gds-sys-color-")) {
+        return fullMatch;
+      }
+      const replacedValue = quotedValue.replace(
+        SHORTHAND_TOKEN_REGEX,
+        (token) => SHORTHAND_RENAME_MAP.get(token) ?? token
+      );
+      if (replacedValue === quotedValue) {
+        return fullMatch;
+      }
+      return `${quote}${replacedValue}${quote}`;
+    }
+  );
+}
+function detect(filePath, content) {
+  const matches = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    TOKEN_REGEX.lastIndex = 0;
+    let match;
+    while ((match = TOKEN_REGEX.exec(line)) !== null) {
+      const token = match[0];
+      const renamed = RENAME_MAP.get(token);
+      if (renamed) {
+        matches.push({
+          file: filePath,
+          line: i + 1,
+          match: token,
+          message: `Rename ${token} to ${renamed} (3.0 color token rename).`
+        });
+        continue;
+      }
+      if (DELETED_SET.has(token)) {
+        matches.push({
+          file: filePath,
+          line: i + 1,
+          match: token,
+          message: `${token} is marked as deleted in 3.0 replacement table. Update this usage manually to a valid replacement.`,
+          manualReview: true
+        });
+        continue;
+      }
+      if (LEGACY_SET.has(token)) {
+        matches.push({
+          file: filePath,
+          line: i + 1,
+          match: token,
+          message: `${token} is a legacy token and is not covered by deterministic 3.0 mapping. Review manually.`,
+          manualReview: true
+        });
+      }
+    }
+    matches.push(...detectShorthandExpressionMatches(filePath, line, i + 1));
+  }
+  return matches;
+}
+function apply(_filePath, content) {
+  let result = content.replace(
+    RENAME_REGEX,
+    (match) => RENAME_MAP.get(match) ?? match
+  );
+  const lines = result.split("\n");
+  const replacedLines = lines.map(
+    (line) => replaceShorthandExpressionsInLine(line)
+  );
+  result = replacedLines.join("\n");
+  return result !== content ? result : null;
+}
+const unit = {
+  id: "color-token-renames",
+  enabled: true,
+  summary: "Rename 3.0 color tokens and flag deleted/legacy tokens for manual review",
+  exampleBefore: [
+    ".button {",
+    "  border-color: var(--gds-sys-color-border-subtle-01);",
+    "  color: var(--gds-sys-color-content-inversed);",
+    "  background: var(--gds-sys-color-l3-neutral-01);",
+    "}",
+    ".badge {",
+    "  background: var(--gds-sys-color-l3-disabled-03);",
+    "}"
+  ].join("\n"),
+  exampleAfter: [
+    ".button {",
+    "  border-color: var(--gds-sys-color-border-neutral-02);",
+    "  color: var(--gds-sys-color-content-neutral-05);",
+    "  background: var(--gds-sys-color-l3-neutral-03);",
+    "}",
+    ".badge {",
+    "  background: var(--gds-sys-color-l3-disabled-03); /* review manually */",
+    "}"
+  ].join("\n"),
+  fileExtensions: [".css", ".scss", ".less", ".html", ".ts", ".tsx", ".js"],
+  safe: false,
+  detect,
+  apply
+};
+export {
+  unit
+};

package/bin/context-cli/migrate/units/3/rename-group-direction-to-flex-direction.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationUnit } from '../../types.js';
+export declare const unit: MigrationUnit;