@almadar/core 2.9.1 → 2.10.0

package/dist/{compose-behaviors-C42E5T3f.d.ts → adapt-behavior-WWazE3lN.d.ts}

@@ -1,4 +1,4 @@
-import { O as OrbitalDefinition, b as OrbitalSchema } from './schema-B2HUtPrQ.js';
+import { O as OrbitalDefinition, b as OrbitalSchema, a as EntityPersistence } from './schema-B2HUtPrQ.js';
 
 /**
  * Event Wiring
@@ -116,4 +116,46 @@ interface ComposeBehaviorsResult {
  */
 declare function composeBehaviors(input: ComposeBehaviorsInput): ComposeBehaviorsResult;
 
-export { type ComposeBehaviorsInput as C, type EventWiringEntry as E, type LayoutStrategy as L, type ComposeBehaviorsResult as a, applyEventWiring as b, composeBehaviors as c, detectLayoutStrategy as d };
+/**
+ * Adapt Behavior Builder
+ *
+ * Deterministically rebinds a behavior's entity, fields, traits, and pages
+ * to a target entity. No LLM involved. Render-UI trees stay from the behavior.
+ *
+ * Uses core types (OrbitalDefinition, Entity, EntityField, Trait, Page)
+ * instead of untyped Record<string, unknown>.
+ *
+ * @packageDocumentation
+ */
+
+interface AdaptBehaviorInput {
+    /** Source orbital definition (from a golden behavior) */
+    source: OrbitalDefinition;
+    /** Target entity name (PascalCase) */
+    entityName: string;
+    /** Target fields */
+    fields: Array<{
+        name: string;
+        type: string;
+        required?: boolean;
+    }>;
+    /** Target collection name (defaults to plural lowercase of entityName) */
+    collection?: string;
+    /** Persistence mode (defaults to "persistent") */
+    persistence?: EntityPersistence;
+}
+interface AdaptBehaviorResult {
+    /** The adapted orbital definition */
+    orbital: OrbitalDefinition;
+}
+/**
+ * Adapt a behavior orbital to a new entity.
+ *
+ * Rebinds: entity name, collection, fields, trait names, page names/paths,
+ * entity references in render-ui trees and effects.
+ *
+ * Preserves: state machine structure, transitions, render-ui trees, event wiring.
+ */
+declare function adaptBehavior(input: AdaptBehaviorInput): AdaptBehaviorResult;
+
+export { type AdaptBehaviorInput as A, type ComposeBehaviorsInput as C, type EventWiringEntry as E, type LayoutStrategy as L, type AdaptBehaviorResult as a, type ComposeBehaviorsResult as b, adaptBehavior as c, applyEventWiring as d, composeBehaviors as e, detectLayoutStrategy as f };

package/dist/builders.d.ts

@@ -1,5 +1,5 @@
 import { T as TraitEventContract, E as EntityField, a as EntityPersistence, O as OrbitalDefinition, b as OrbitalSchema, c as Trait, d as Entity, P as Page } from './schema-B2HUtPrQ.js';
-export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-C42E5T3f.js';
+export { A as AdaptBehaviorInput, a as AdaptBehaviorResult, C as ComposeBehaviorsInput, b as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, c as adaptBehavior, d as applyEventWiring, e as composeBehaviors, f as detectLayoutStrategy } from './adapt-behavior-WWazE3lN.js';
 import 'zod';
 import '@almadar/patterns';
 

package/dist/builders.js

@@ -411,6 +411,164 @@ function composeBehaviors(input) {
   };
 }
 
+// src/builders/adapt-behavior.ts
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "timestamp",
+  "datetime",
+  "array",
+  "object",
+  "enum",
+  "relation"
+]);
+function normalizeFieldType(type) {
+  if (type.endsWith("[]")) return "array";
+  const lower = type.toLowerCase();
+  if (VALID_FIELD_TYPES.has(lower)) return lower;
+  return "string";
+}
+function deriveTraitSuffix(originalEntityName, traits) {
+  if (!traits.length) return "Management";
+  const traitName = traits[0].name;
+  if (traitName.startsWith(originalEntityName)) {
+    const suffix = traitName.slice(originalEntityName.length);
+    if (suffix && suffix.toLowerCase() !== originalEntityName.toLowerCase()) {
+      return suffix;
+    }
+  }
+  const lower = originalEntityName.toLowerCase();
+  const traitLower = traitName.toLowerCase();
+  if (traitLower.startsWith(lower)) {
+    const suffix = traitName.slice(lower.length);
+    if (suffix && suffix.toLowerCase() !== originalEntityName.toLowerCase()) {
+      return suffix;
+    }
+  }
+  return "Management";
+}
+function replaceEntityRefs(obj, oldEntity, newEntity) {
+  if (typeof obj === "string") {
+    return obj === oldEntity ? newEntity : obj.replace(new RegExp(oldEntity, "g"), newEntity);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => replaceEntityRefs(item, oldEntity, newEntity));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = replaceEntityRefs(value, oldEntity, newEntity);
+    }
+    return result;
+  }
+  return obj;
+}
+function cleanStaleBindings(stateMachine, validFields) {
+  const sm = stateMachine;
+  const transitions = sm.transitions;
+  if (!transitions) return;
+  for (const transition of transitions) {
+    const effects = transition.effects;
+    if (!effects) continue;
+    transition.effects = effects.filter((effect) => {
+      if (!Array.isArray(effect)) return true;
+      return !hasStaleBinding(effect, validFields);
+    });
+  }
+}
+function hasStaleBinding(value, validFields) {
+  if (typeof value === "string") {
+    if (value.startsWith("@entity.")) {
+      const field = value.slice("@entity.".length).split(".")[0];
+      return !validFields.has(field);
+    }
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.some((item) => hasStaleBinding(item, validFields));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some((v) => hasStaleBinding(v, validFields));
+  }
+  return false;
+}
+function adaptBehavior(input) {
+  const { source, entityName, fields, collection, persistence } = input;
+  const orbital = JSON.parse(JSON.stringify(source));
+  const originalEntity = typeof orbital.entity === "string" ? orbital.entity : orbital.entity.name;
+  const targetCollection = collection ?? entityName.toLowerCase() + "s";
+  orbital.entity = {
+    name: entityName,
+    collection: targetCollection,
+    persistence: persistence ?? "persistent",
+    fields: [
+      { name: "id", type: "string", required: true },
+      ...fields.map((f) => ({
+        name: f.name,
+        type: normalizeFieldType(f.type),
+        ...f.required ? { required: true } : {}
+      }))
+    ].filter((f, i, arr) => arr.findIndex((x) => x.name === f.name) === i)
+    // dedupe id
+  };
+  const inlineTraits = orbital.traits.filter((t) => isInlineTrait(t));
+  const firstTraitSuffix = deriveTraitSuffix(originalEntity, inlineTraits);
+  const traitNameMap = /* @__PURE__ */ new Map();
+  for (const trait of inlineTraits) {
+    const oldTraitName = trait.name;
+    let newTraitName;
+    if (trait.name.toLowerCase().startsWith(originalEntity.toLowerCase())) {
+      const suffix = trait.name.slice(originalEntity.length) || firstTraitSuffix;
+      newTraitName = entityName + suffix;
+    } else {
+      newTraitName = entityName + trait.name;
+    }
+    traitNameMap.set(oldTraitName, newTraitName);
+    trait.name = newTraitName;
+    trait.linkedEntity = entityName;
+    if (trait.stateMachine) {
+      trait.stateMachine = replaceEntityRefs(
+        trait.stateMachine,
+        originalEntity,
+        entityName
+      );
+      trait.stateMachine = replaceEntityRefs(
+        trait.stateMachine,
+        oldTraitName,
+        newTraitName
+      );
+      const newFieldNames = new Set(fields.map((f) => f.name));
+      newFieldNames.add("id");
+      cleanStaleBindings(trait.stateMachine, newFieldNames);
+    }
+  }
+  orbital.name = entityName + firstTraitSuffix;
+  if (orbital.pages) {
+    for (const page of orbital.pages) {
+      if (typeof page === "string") continue;
+      const p = page;
+      if (p.name) p.name = entityName + "Page";
+      if (p.path) p.path = "/" + targetCollection;
+      if (p.traits) {
+        for (const ref of p.traits) {
+          if (typeof ref === "object" && "ref" in ref) {
+            ref.ref = traitNameMap.get(ref.ref) ?? entityName + firstTraitSuffix;
+          }
+        }
+      }
+    }
+  }
+  if ("domainContext" in orbital) {
+    const ctx = orbital.domainContext;
+    if (ctx?.vocabulary && typeof ctx.vocabulary === "object") {
+      ctx.vocabulary.item = entityName.toLowerCase();
+    }
+  }
+  return { orbital };
+}
+
 // src/builders.ts
 function ensureIdField(fields) {
   if (fields.some((f) => f.name === "id")) return fields;
@@ -570,6 +728,6 @@ function pipe(orbitals, events, appName) {
   };
 }
 
-export { applyEventWiring, compose, composeBehaviors, connect, detectLayoutStrategy, ensureIdField, extractTrait, makeEntity, makeOrbital, makePage, mergeOrbitals, pipe, plural, wire };
+export { adaptBehavior, applyEventWiring, compose, composeBehaviors, connect, detectLayoutStrategy, ensureIdField, extractTrait, makeEntity, makeOrbital, makePage, mergeOrbitals, pipe, plural, wire };
 //# sourceMappingURL=builders.js.map
 //# sourceMappingURL=builders.js.map