@almadar/core 7.19.1 → 7.21.0

package/dist/domain-language/index.js

@@ -3410,7 +3410,9 @@ var FieldTypeSchema = z.enum([
   "object",
   "enum",
   "relation",
-  "trait"
+  "trait",
+  "slot",
+  "pattern"
 ]);
 var RelationCardinalitySchema = z.enum([
   "one",
@@ -6397,6 +6399,251 @@ function parseEffectFromText(text) {
   }
 }
 
+// src/domain-language/types.ts
+var DOMAIN_TO_SCHEMA_FIELD_TYPE = {
+  "text": "string",
+  "long text": "string",
+  "number": "number",
+  "currency": "number",
+  "yes/no": "boolean",
+  "date": "date",
+  "timestamp": "timestamp",
+  "datetime": "datetime",
+  "list": "array",
+  "object": "object",
+  "enum": "enum",
+  "relation": "relation"
+};
+var UI_SLOTS2 = [
+  "main",
+  "sidebar",
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "hud-top",
+  "hud-bottom",
+  "floating",
+  "system"
+];
+
+// src/domain-language/sync/translate-domain-to-params.ts
+function translateDomainToParams(binding, signature, presentation) {
+  const warnings = [];
+  const params = {};
+  applyEntityName(binding.entity, signature, params);
+  applyEntityFields(binding.entity, signature, params, warnings);
+  applyPersistence(binding.entity, signature, params, warnings);
+  applyPagePaths(binding.pages ?? [], signature, params, warnings);
+  applyPresentation(presentation, signature, params, warnings);
+  return {
+    callSite: {
+      organism: signature.organism,
+      orbital: signature.orbital,
+      factoryPath: signature.factoryPath,
+      params
+    },
+    warnings
+  };
+}
+function applyEntityName(entity, signature, params) {
+  if (signature.entities.length === 0) return;
+  if (entity.name === signature.entities[0].name) return;
+  params.entityName = entity.name;
+}
+function applyEntityFields(entity, signature, params, warnings) {
+  if (signature.entities.length === 0) {
+    if (entity.fields.length > 0) {
+      warnings.push({
+        field: `entity.${entity.name}.fields`,
+        reason: "factory signature does not advertise an entity surface"
+      });
+    }
+    return;
+  }
+  const canonical = new Set(signature.entities[0].fields.map((f) => f.name));
+  const extras = [];
+  for (const f of entity.fields) {
+    if (canonical.has(f.name)) continue;
+    const lowered = lowerField(f);
+    if (lowered) extras.push(lowered);
+  }
+  if (extras.length > 0) params.entityFields = extras;
+}
+function applyPersistence(entity, signature, params, warnings) {
+  if (!entity.persistence) return;
+  if (signature.entities.length === 0) {
+    warnings.push({
+      field: `entity.${entity.name}.persistence`,
+      reason: "factory signature has no entity to apply persistence to"
+    });
+    return;
+  }
+  if (entity.persistence === signature.entities[0].persistence) return;
+  params.persistence = entity.persistence;
+}
+function applyPagePaths(pages, signature, params, warnings) {
+  if (pages.length === 0) return;
+  const sigPages = new Map(signature.pages.map((p) => [p.name, p]));
+  const overrides = {};
+  for (const p of pages) {
+    const sig = sigPages.get(p.name);
+    if (!sig) {
+      warnings.push({
+        field: `page.${p.name}.url`,
+        reason: `factory signature has no page named "${p.name}"`
+      });
+      continue;
+    }
+    if (sig.defaultPath !== p.url) overrides[p.name] = p.url;
+  }
+  if (Object.keys(overrides).length > 0) params.pagePaths = overrides;
+}
+function applyPresentation(overlay, signature, params, warnings) {
+  if (!overlay?.navAdditions || overlay.navAdditions.length === 0) return;
+  const target = signature.traits.find(
+    (t) => t.overridableConfigKeys.includes("navItems")
+  );
+  if (!target) {
+    warnings.push({
+      field: "presentation.navAdditions",
+      reason: "factory signature has no trait advertising a `navItems` config key"
+    });
+    return;
+  }
+  const existing = params.traitOverrides?.[target.name] ?? {};
+  const existingConfig = existing.config ?? {};
+  const items = overlay.navAdditions.map(
+    navItemToParamValue
+  );
+  params.traitOverrides = {
+    ...params.traitOverrides,
+    [target.name]: {
+      ...existing,
+      config: { ...existingConfig, navItems: items }
+    }
+  };
+}
+function lowerField(f) {
+  const schemaType = DOMAIN_TO_SCHEMA_FIELD_TYPE[f.fieldType];
+  if (!schemaType) return void 0;
+  const out = {
+    name: f.name,
+    type: schemaType
+  };
+  if (f.required === true) out.required = true;
+  if (f.enumValues && f.enumValues.length > 0) out.values = [...f.enumValues];
+  if (f.default !== void 0) out.default = lowerDefault(f.default);
+  if (f.items) {
+    const itemSchema = DOMAIN_TO_SCHEMA_FIELD_TYPE[f.items.type];
+    if (itemSchema) out.items = { type: itemSchema };
+  }
+  return out;
+}
+function lowerDefault(d) {
+  if (d === void 0 || d === null) return d;
+  if (typeof d === "string" || typeof d === "number" || typeof d === "boolean") {
+    return d;
+  }
+  if (Array.isArray(d)) {
+    return d.map(lowerDefault);
+  }
+  if (typeof d === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(d)) out[k] = lowerDefault(v);
+    return out;
+  }
+  return void 0;
+}
+function navItemToParamValue(item) {
+  const out = {
+    label: item.label,
+    path: item.path
+  };
+  if (item.icon) out.icon = item.icon;
+  return out;
+}
+
+// src/domain-language/sync/diff-factory-calls.ts
+function diffFactoryCalls(prior, next) {
+  const out = [];
+  const priorByKey = new Map(prior.map((c) => [callKey(c), c]));
+  const nextByKey = new Map(next.map((c) => [callKey(c), c]));
+  for (const [key, p] of priorByKey) {
+    const n = nextByKey.get(key);
+    if (!n) {
+      out.push({ kind: "delete", orbitalName: p.orbital, prior: p });
+      continue;
+    }
+    if (paramsEqual(p.params, n.params)) {
+      out.push({ kind: "keep", orbitalName: p.orbital, call: n });
+    } else {
+      out.push({ kind: "edit", orbitalName: p.orbital, prior: p, next: n });
+    }
+  }
+  for (const [key, n] of nextByKey) {
+    if (!priorByKey.has(key)) {
+      out.push({ kind: "add", orbitalName: n.orbital, next: n });
+    }
+  }
+  return out;
+}
+function callKey(c) {
+  return `${c.organism}::${c.orbital}`;
+}
+function paramsEqual(a, b) {
+  return canonicalParams(a) === canonicalParams(b);
+}
+function canonicalParams(p) {
+  const keys = [
+    "entityFields",
+    "entityName",
+    "extraTraits",
+    "pagePaths",
+    "persistence",
+    "traitOverrides"
+  ];
+  const parts = [];
+  for (const k of keys) {
+    const v = p[k];
+    if (v === void 0) continue;
+    parts.push(`${k}:${canonicalNode(v)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function canonicalNode(v) {
+  if (v === void 0) return "u";
+  if (typeof v === "string") return JSON.stringify(v);
+  if (Array.isArray(v)) {
+    return `[${v.map((x) => canonicalParamValue(x)).join(",")}]`;
+  }
+  const keys = Object.keys(v).sort();
+  const parts = [];
+  for (const k of keys) {
+    const child = v[k];
+    parts.push(`${JSON.stringify(k)}:${canonicalParamValue(child)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function canonicalParamValue(v) {
+  if (v === null || v === void 0) return "u";
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return `[${v.map(canonicalParamValue).join(",")}]`;
+  }
+  const keys = Object.keys(v).sort();
+  const parts = [];
+  for (const k of keys) {
+    const child = v[k];
+    if (child === void 0) continue;
+    parts.push(`${JSON.stringify(k)}:${canonicalParamValue(child)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+
 // src/domain-language/sync/section-mapping.ts
 function createMappingStore(mappings = []) {
   return {
@@ -6617,21 +6864,6 @@ function formatMergeSummary(result) {
   return parts.join(", ") || "empty";
 }
 
-// src/domain-language/types.ts
-var UI_SLOTS2 = [
-  "main",
-  "sidebar",
-  "modal",
-  "drawer",
-  "overlay",
-  "center",
-  "toast",
-  "hud-top",
-  "hud-bottom",
-  "floating",
-  "system"
-];
-
 // src/domain-language/registry.ts
 var FIELD_TYPE_REGISTRY = {
   string: {
@@ -7069,6 +7301,141 @@ function generateDomainLanguageReference() {
   return lines.join("\n");
 }
 
-export { EFFECT_REGISTRY, FIELD_TYPE_REGISTRY, GUARD_REGISTRY, KEYWORDS, Lexer, MULTI_WORD_KEYWORDS, TokenType, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };
+// src/domain-language/applyMutation.ts
+function applyMutation(doc, mut) {
+  switch (mut.kind) {
+    case "add-entity":
+      return { ...doc, entities: [...doc.entities, mut.entity] };
+    case "remove-entity":
+      return {
+        ...doc,
+        entities: doc.entities.filter((e) => e.name !== mut.entityName)
+      };
+    case "rename-entity":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.from, (e) => ({
+          ...e,
+          name: mut.to
+        }))
+      };
+    case "update-entity":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, () => mut.entity)
+      };
+    case "add-field":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          fields: [...e.fields, mut.field]
+        }))
+      };
+    case "remove-field":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          fields: e.fields.filter((f) => f.name !== mut.fieldName)
+        }))
+      };
+    case "update-field":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          fields: replaceField(e.fields, mut.field)
+        }))
+      };
+    case "add-page":
+      return { ...doc, pages: [...doc.pages, mut.page] };
+    case "remove-page":
+      return {
+        ...doc,
+        pages: doc.pages.filter((p) => p.name !== mut.pageName)
+      };
+    case "update-page":
+      return {
+        ...doc,
+        pages: replacePage(doc.pages, mut.pageName, () => mut.page)
+      };
+    case "add-behavior":
+      return { ...doc, behaviors: [...doc.behaviors, mut.behavior] };
+    case "remove-behavior":
+      return {
+        ...doc,
+        behaviors: doc.behaviors.filter((b) => b.name !== mut.behaviorName)
+      };
+    case "update-behavior":
+      return {
+        ...doc,
+        behaviors: replaceBehavior(
+          doc.behaviors,
+          mut.behaviorName,
+          () => mut.behavior
+        )
+      };
+    case "add-transition":
+      return {
+        ...doc,
+        behaviors: replaceBehavior(doc.behaviors, mut.behaviorName, (b) => ({
+          ...b,
+          transitions: [...b.transitions, mut.transition]
+        }))
+      };
+    case "remove-transition":
+      return {
+        ...doc,
+        behaviors: replaceBehavior(doc.behaviors, mut.behaviorName, (b) => ({
+          ...b,
+          transitions: b.transitions.filter(
+            (t) => !matchesTransition(t, mut.from, mut.to, mut.event)
+          )
+        }))
+      };
+    case "add-relationship":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          relationships: [...e.relationships, mut.relationship]
+        }))
+      };
+    case "remove-relationship":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          relationships: e.relationships.filter(
+            (r) => !matchesRelationship(r, mut.targetEntity, mut.relationshipType)
+          )
+        }))
+      };
+    default: {
+      return doc;
+    }
+  }
+}
+function replaceEntity(entities, name, update) {
+  return entities.map((e) => e.name === name ? update(e) : e);
+}
+function replaceField(fields, next) {
+  return fields.map((f) => f.name === next.name ? next : f);
+}
+function replacePage(pages, name, update) {
+  return pages.map((p) => p.name === name ? update(p) : p);
+}
+function replaceBehavior(behaviors, name, update) {
+  return behaviors.map((b) => b.name === name ? update(b) : b);
+}
+function matchesTransition(t, from, to, event) {
+  return t.fromState === from && t.toState === to && t.event === event;
+}
+function matchesRelationship(r, targetEntity, relationshipType) {
+  return r.targetEntity === targetEntity && r.relationshipType === relationshipType;
+}
+
+export { EFFECT_REGISTRY, FIELD_TYPE_REGISTRY, GUARD_REGISTRY, KEYWORDS, Lexer, MULTI_WORD_KEYWORDS, TokenType, applyMutation, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, diffFactoryCalls, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, translateDomainToParams, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map