@khaledeltohamy14/token-pipeline-engine 1.0.0

package/README.md

@@ -0,0 +1,12 @@
+# @khaledeltohamy14/token-pipeline-engine
+
+Shared token pipeline used by Galaxy and generated repositories.
+
+## API
+
+- `splitTokenDocument(document)`
+- `splitTokenFiles(document)`
+- `generateTokenFiles({ document })`
+- `generateRepositoryFiles({ document })`
+
+The engine is filesystem-free. It returns `{ path, content, mode }` objects so Galaxy can send them directly to GitHub and Node CI can write them to disk.

package/generators/alias-generator.js

@@ -0,0 +1,257 @@
+const {
+  flattenTokens,
+  getTokenValue,
+  getTokenType,
+  isReference,
+  cleanReference,
+  toDartIdentifier,
+  colorValue,
+  dimensionValue,
+} = require('./token-utils');
+
+function renderAliasTokens({
+  tokens,
+  globalTokens,
+}) {
+  const aliasMap = flattenTokens(tokens);
+  const globalMap = flattenTokens(globalTokens);
+
+  let output =
+    `// GENERATED FILE - DO NOT EDIT\n` +
+    `// ignore_for_file: constant_identifier_names\n\n` +
+    `import 'dart:ui';\n` +
+    `import '../global/global_tokens.dart';\n\n`;
+
+  output +=
+    `class AliasTokens {\n` +
+    `  AliasTokens._();\n\n`;
+
+  for (const [tokenPath, token] of Object.entries(aliasMap)) {
+    const tokenName = toDartIdentifier(tokenPath);
+
+    const rawValue = getTokenValue(token);
+    const type = getTokenType(token);
+
+    const resolved = resolveAliasReference({
+      value: rawValue,
+      aliasMap,
+      globalMap,
+      stack: [],
+    });
+
+    const dart = generateDartValue({
+      type,
+      resolved,
+      tokenPath,
+    });
+
+    output +=
+      `  static const ${dart.type} ` +
+      `${tokenName} = ${dart.value};\n\n`;
+  }
+
+  output += `}\n`;
+
+  return output;
+}
+
+// ============================================================
+// RESOLVE ALIAS
+// ============================================================
+
+function resolveAliasReference({
+  value,
+  aliasMap,
+  globalMap,
+  stack,
+}) {
+  if (!isReference(value)) {
+    return {
+      value,
+      sourceLayer: 'literal',
+      sourcePath: null,
+    };
+  }
+
+  const referencePath = cleanReference(value);
+
+  // ----------------------------------------
+  // Alias → Alias
+  // ----------------------------------------
+
+  if (aliasMap[referencePath]) {
+    if (stack.includes(referencePath)) {
+      throw new Error(
+        `❌ Circular alias reference:\n` +
+        `${[...stack, referencePath].join(' -> ')}`
+      );
+    }
+
+    const nextValue =
+      getTokenValue(aliasMap[referencePath]);
+
+    const resolved = resolveAliasReference({
+      value: nextValue,
+      aliasMap,
+      globalMap,
+      stack: [
+        ...stack,
+        referencePath,
+      ],
+    });
+
+    return {
+      ...resolved,
+      sourceLayer: 'alias',
+      sourcePath: referencePath,
+    };
+  }
+
+  // ----------------------------------------
+  // Alias → Global
+  // ----------------------------------------
+
+  if (globalMap[referencePath]) {
+    const globalValue =
+      getTokenValue(globalMap[referencePath]);
+
+    if (isReference(globalValue)) {
+      return resolveAliasReference({
+        value: globalValue,
+        aliasMap,
+        globalMap,
+        stack,
+      });
+    }
+
+    return {
+      value: globalValue,
+      sourceLayer: 'global',
+      sourcePath: referencePath,
+    };
+  }
+
+  throw new Error(
+    `❌ Broken reference in alias.json:\n` +
+    `"${value}"\n` +
+    `Expected global or alias token: ${referencePath}`
+  );
+}
+
+// ============================================================
+// DART VALUE
+// ============================================================
+
+function generateDartValue({
+  type,
+  resolved,
+  tokenPath,
+}) {
+  // ----------------------------------------
+  // GLOBAL REFERENCE
+  // ----------------------------------------
+
+  if (resolved.sourceLayer === 'global') {
+    return {
+      type: dartType(type),
+      value:
+        `GlobalTokens.${toDartIdentifier(
+          resolved.sourcePath
+        )}`,
+    };
+  }
+
+  // ----------------------------------------
+  // LITERAL
+  // ----------------------------------------
+
+  if (type === 'color') {
+    const color = colorValue(
+      resolved.value
+    );
+
+    if (!color) {
+      throw new Error(
+        `❌ Invalid color token:\n` +
+        `${tokenPath}`
+      );
+    }
+
+    return {
+      type: 'Color',
+      value: color,
+    };
+  }
+
+  if (type === 'dimension') {
+    const dimension =
+      dimensionValue(resolved.value);
+
+    if (dimension === null) {
+      throw new Error(
+        `❌ Invalid dimension token:\n` +
+        `${tokenPath}`
+      );
+    }
+
+    return {
+      type: 'double',
+      value: dimension,
+    };
+  }
+
+  if (type === 'string') {
+    return {
+      type: 'String',
+      value: JSON.stringify(
+        String(resolved.value)
+      ),
+    };
+  }
+
+  if (type === 'number') {
+    return {
+      type: 'double',
+      value: String(resolved.value),
+    };
+  }
+
+  if (type === 'boolean') {
+    return {
+      type: 'bool',
+      value:
+        resolved.value ? 'true' : 'false',
+    };
+  }
+
+  throw new Error(
+    `❌ Unsupported alias token type:\n` +
+    `${tokenPath}`
+  );
+}
+
+function dartType(type) {
+  switch (type) {
+    case 'color':
+      return 'Color';
+
+    case 'dimension':
+      return 'double';
+
+    case 'string':
+      return 'String';
+
+    case 'number':
+      return 'double';
+
+    case 'boolean':
+      return 'bool';
+
+    default:
+      throw new Error(
+        `Unsupported type: ${type}`
+      );
+  }
+}
+
+module.exports = { renderAliasTokens };

package/generators/brand-generator.js

@@ -0,0 +1,68 @@
+const {
+flattenTokens, getTokenValue, getTokenType,
+  isReference, cleanReference, toDartIdentifier, colorValue, dimensionValue, dartType,
+} = require('./token-utils');
+
+function renderBrandTokens({ brandTokens, aliasTokens, globalTokens, className }) {
+  const map = {
+    ...flattenTokens(brandTokens.global || {}),
+    ...flattenTokens(brandTokens.alias || {}),
+    ...flattenTokens(brandTokens.component || {}),
+  };
+  // Backward-compatible flat brand files (without layer keys).
+  if (Object.keys(map).length === 0) Object.assign(map, flattenTokens(brandTokens || {}));
+  const aliasMap = flattenTokens(aliasTokens || {});
+  const globalMap = flattenTokens(globalTokens || {});
+  const body = [];
+  let needsUi = false, needsAlias = false, needsGlobal = false;
+
+  for (const [tokenPath, token] of Object.entries(map)) {
+    const type = getTokenType(token) || inferReferenceType(token, tokenPath, aliasMap, globalMap);
+    const resolved = resolve(getTokenValue(token), type, aliasMap, globalMap, []);
+    needsUi ||= resolved.type === 'Color';
+    needsAlias ||= resolved.value.startsWith('AliasTokens.');
+    needsGlobal ||= resolved.value.startsWith('GlobalTokens.');
+    body.push(`  static const ${resolved.type} ${toDartIdentifier(tokenPath)} = ${resolved.value};`, '');
+  }
+
+  const out = ['// GENERATED FILE - DO NOT EDIT', ''];
+  if (needsUi) out.push("import 'dart:ui';");
+  if (needsGlobal) out.push("import '../global/global_tokens.dart';");
+  if (needsAlias) out.push("import '../alias/alias_tokens.dart';");
+  if (needsUi || needsGlobal || needsAlias) out.push('');
+  out.push(`class ${className} {`, `  ${className}._();`, '', ...body, '}','');
+  return out.join('\n');
+}
+
+function inferReferenceType(token, tokenPath, aliasMap, globalMap) {
+  const value = getTokenValue(token);
+  if (!isReference(value)) throw new Error(`❌ Brand token has no type: ${tokenPath}`);
+  const ref = cleanReference(value);
+  const target = aliasMap[ref] || globalMap[ref];
+  if (!target) throw new Error(`❌ Broken brand reference: {${ref}}`);
+  return getTokenType(target);
+}
+
+function resolve(value, type, aliasMap, globalMap, stack) {
+  if (isReference(value)) {
+    const ref = cleanReference(value);
+    if (stack.includes(ref)) throw new Error(`❌ Circular brand reference: ${[...stack, ref].join(' -> ')}`);
+    if (aliasMap[ref]) return resolve(getTokenValue(aliasMap[ref]), getTokenType(aliasMap[ref]), aliasMap, globalMap, [...stack, ref]);
+    if (globalMap[ref]) return resolve(getTokenValue(globalMap[ref]), getTokenType(globalMap[ref]), aliasMap, globalMap, [...stack, ref]);
+    throw new Error(`❌ Broken brand reference: {${ref}}`);
+  }
+  if (type === 'color') {
+    const c = colorValue(value); if (!c) throw new Error(`❌ Invalid brand color: ${value}`);
+    return { type: 'Color', value: c };
+  }
+  if (type === 'dimension') {
+    const d = dimensionValue(value); if (d === null) throw new Error(`❌ Invalid brand dimension: ${value}`);
+    return { type: 'double', value: d };
+  }
+  if (type === 'number') return { type: 'double', value: String(value) };
+  if (type === 'string') return { type: 'String', value: JSON.stringify(String(value)) };
+  if (type === 'boolean') return { type: 'bool', value: value ? 'true' : 'false' };
+  throw new Error(`❌ Unsupported brand token type: ${type}`);
+}
+
+module.exports = { renderBrandTokens };

package/generators/category-generator.js

@@ -0,0 +1,44 @@
+const { flattenTokens, getTokenValue, getTokenType, isReference, cleanReference, toDartIdentifier, colorValue, dimensionValue, dartType } = require('./token-utils');
+
+function renderCategoryTokens({ tokens, globalTokens, aliasTokens, className }) {
+  const map = flattenTokens(tokens || {});
+  const globalMap = flattenTokens(globalTokens || {});
+  const aliasMap = flattenTokens(aliasTokens || {});
+  const body = [];
+  let needsUi = false, needsGlobal = false, needsAlias = false;
+
+  for (const [tokenPath, token] of Object.entries(map)) {
+    const type = getTokenType(token);
+    const raw = getTokenValue(token);
+    const expr = resolve(raw, globalMap, aliasMap, type, tokenPath);
+    needsUi ||= expr.type === 'Color';
+    needsGlobal ||= expr.value.startsWith('GlobalTokens.');
+    needsAlias ||= expr.value.startsWith('AliasTokens.');
+    body.push(`  static const ${expr.type} ${toDartIdentifier(tokenPath)} = ${expr.value};`, '');
+  }
+
+  const out = ['// GENERATED FILE - DO NOT EDIT', ''];
+  if (needsUi) out.push("import 'dart:ui';");
+  if (needsGlobal) out.push("import '../global/global_tokens.dart';");
+  if (needsAlias) out.push("import '../alias/alias_tokens.dart';");
+  if (needsUi || needsGlobal || needsAlias) out.push('');
+  out.push(`class ${className} {`, `  ${className}._();`, '', ...body, '}','');
+  return out.join('\n');
+}
+
+function resolve(value, globalMap, aliasMap, type, tokenPath) {
+  if (isReference(value)) {
+    const p = cleanReference(value);
+    if (aliasMap[p]) return { type: dartType(type), value: `AliasTokens.${toDartIdentifier(p)}` };
+    if (globalMap[p]) return { type: dartType(type), value: `GlobalTokens.${toDartIdentifier(p)}` };
+    throw new Error(`❌ Broken reference in ${tokenPath}: {${p}}`);
+  }
+  if (type === 'color') { const c = colorValue(value); if (!c) throw new Error(`❌ Invalid color: ${value}`); return { type: 'Color', value: c }; }
+  if (type === 'dimension') { const d = dimensionValue(value); if (d === null) throw new Error(`❌ Invalid dimension: ${value}`); return { type: 'double', value: d }; }
+  if (type === 'number') return { type: 'double', value: String(value) };
+  if (type === 'string') return { type: 'String', value: JSON.stringify(String(value)) };
+  if (type === 'boolean') return { type: 'bool', value: value ? 'true' : 'false' };
+  throw new Error(`❌ Unsupported token type: ${type}`);
+}
+
+module.exports = { renderCategoryTokens };