form0-core 0.6.0 → 0.7.0

package/src/engine/managed-events.js

@@ -30,6 +30,10 @@ function copy(value, seen = new Map()) {
   return result;
 }
 
+const managedReferenceCaches = new WeakMap();
+const managedFieldCaches = new WeakMap();
+const managedRepeatableCaches = new WeakMap();
+
 /** Internal adapter; the public synchronous API is engine.triggerDetailed(). */
 export function createManagedEventDispatcher(manager, constructionScope) {
   const instancePath = copy(constructionScope?.instancePath);
@@ -37,18 +41,27 @@ export function createManagedEventDispatcher(manager, constructionScope) {
   if (scopeId !== undefined && (typeof scopeId !== 'string' || !scopeId.trim()))
     throw new Error('eventScope.scopeId must be a nonempty string when supplied.');
   const resolver = manager.contextResolver;
-  const fields = new Map(resolver.fieldOwnership);
+  if (!managedFieldCaches.has(resolver))
+    managedFieldCaches.set(resolver, new Map(resolver.fieldOwnership));
+  const fields = managedFieldCaches.get(resolver);
+  if (!managedRepeatableCaches.has(resolver))
+    managedRepeatableCaches.set(
+      resolver,
+      new Map(
+        [...resolver.repeatableSectionTree.values()].map((entry) => [
+          JSON.stringify([entry.parentPath, entry.preferredKey]),
+          entry,
+        ])
+      )
+    );
+  const repeatableIndex = managedRepeatableCaches.get(resolver);
   const statusField = manager.schema?.status_field;
   if (statusField?.enabled && typeof statusField.data_name === 'string')
     fields.set(statusField.data_name, { field: statusField, parentPath: [] });
   if (!Array.isArray(instancePath)) throw new Error('eventScope.instancePath must be an array.');
   const ownershipPath = [];
   for (const segment of instancePath) {
-    const repeatable = [...resolver.repeatableSectionTree.values()].find(
-      (entry) =>
-        entry.preferredKey === segment?.repeatableKey &&
-        JSON.stringify(entry.parentPath) === JSON.stringify(ownershipPath)
-    );
+    const repeatable = repeatableIndex.get(JSON.stringify([ownershipPath, segment?.repeatableKey]));
     if (
       !repeatable ||
       JSON.stringify(repeatable.parentPath) !== JSON.stringify(ownershipPath) ||
@@ -70,7 +83,8 @@ export function createManagedEventDispatcher(manager, constructionScope) {
   const readable = (path) =>
     path.length <= ownershipPath.length && path.every((key, index) => ownershipPath[index] === key);
   const ownedField = (name) => fields.get(name) || resolver.repeatableSectionTree.get(name);
-  const referenceCache = new WeakMap();
+  if (!managedReferenceCaches.has(manager)) managedReferenceCaches.set(manager, new WeakMap());
+  const referenceCache = managedReferenceCaches.get(manager);
   return function dispatch(eventType, fieldKey, metadata = {}) {
     const result = { operations: [], validationIssues: [], issues: [] };
     const issue = (code, message) =>
@@ -149,8 +163,12 @@ export function createManagedEventDispatcher(manager, constructionScope) {
       let collected;
       try {
         const source = manager.callbackSources.getSource(callback);
-        if (referenceCache.get(callback)?.source !== source)
-          referenceCache.set(callback, { source, references: getEventFieldReferences(source) });
+        if (referenceCache.get(callback)?.source !== source) {
+          const references =
+            manager.referenceSourceCache?.get(source) ?? getEventFieldReferences(source);
+          manager.referenceSourceCache?.set(source, references);
+          referenceCache.set(callback, { source, references });
+        }
         let rejectedReference = false;
         for (const name of referenceCache.get(callback).references) {
           const field = fields.get(name);

package/src/engine/record-context.js

@@ -0,0 +1,126 @@
+import { ContextResolver } from './context-resolver.js';
+import { expandBuildingPlanSchema } from '../schema/building-plan-expander.js';
+import { validateSchemaWithContext } from '../schema/schema-validator.js';
+import { buildCalculationDependencyPlan } from '../utilities/calculation-dependencies.js';
+import { analyzeRepeatableCollections } from '../utilities/repeatable-collections.js';
+import { createConditionContext } from './condition-context.js';
+import { copyRecordData } from '../utilities/record-data.js';
+
+/** Shared immutable schema preparation; never owns live row engines. */
+export function prepareRecordContext(inputSchema, warningSystem = null) {
+  const sourceSchema = copyRecordData(inputSchema);
+  const { schema } = expandBuildingPlanSchema(sourceSchema);
+  const resolver = new ContextResolver(schema.form);
+  validateSchemaWithContext(schema.form, resolver);
+  const calculationPlan = buildCalculationDependencyPlan(schema.form, resolver);
+  const conditionContext = createConditionContext(schema.form, resolver, warningSystem);
+  const templates = new Map();
+  const repeatableByPath = new Map(
+    [...resolver.repeatableSectionTree.values()].map((entry) => [
+      JSON.stringify(entry.currentPath),
+      entry,
+    ])
+  );
+  const calculations = new Map();
+  for (const [name, node] of calculationPlan.nodesByDataName) {
+    calculations.set(name, {
+      ...node,
+      collection: analyzeRepeatableCollections(node.field.calculate, resolver, name),
+    });
+  }
+  function template(elements, path) {
+    const fields = [];
+    const chains = new Map();
+    function project(items, ancestors = []) {
+      return items.map((field) => {
+        fields.push(field);
+        chains.set(field.data_name, ancestors);
+        if (field.type === 'RepeatableSection') {
+          const key = resolver.repeatableSectionTree.get(field.data_name).preferredKey;
+          template(field.elements || [], [...path, key]);
+          return { ...field, elements: [] };
+        }
+        if (field.type === 'Section' || field.type === 'BuildingPlanSection')
+          return {
+            ...field,
+            elements: project(field.elements || [], [...ancestors, field.data_name]),
+          };
+        return field;
+      });
+    }
+    const localForm = { elements: project(elements) };
+    const status = path.length === 0 ? schema.form.status_field : null;
+    if (status?.enabled) {
+      fields.push(status);
+      chains.set(status.data_name, []);
+    }
+    const result = {
+      path,
+      fields,
+      chains,
+      form: localForm,
+      conditions: { ...conditionContext, fields },
+    };
+    templates.set(JSON.stringify(path), result);
+    return result;
+  }
+  template(schema.form.elements, []);
+  return {
+    schema,
+    sourceSchema,
+    resolver,
+    calculationPlan,
+    templates,
+    calculations,
+    repeatableByPath,
+  };
+}
+
+export function visitRecordScopes(snapshot, context, visit) {
+  function walk(record, path, instancePath, ancestors, participating) {
+    const template = context.templates.get(JSON.stringify(path));
+    const scope = { record, template, instancePath, ancestors, participating };
+    visit(scope);
+    for (const field of template.fields) {
+      if (field.type !== 'RepeatableSection') continue;
+      const info = context.resolver.repeatableSectionTree.get(field.data_name);
+      const rows = record.repeatable?.[info.preferredKey] ?? [];
+      if (!Array.isArray(rows))
+        throw new Error(`RepeatableSection '${field.data_name}' must contain an array of rows.`);
+      const identities = new Set();
+      rows.forEach((row, index) => {
+        if (!row || typeof row !== 'object' || Array.isArray(row))
+          throw new Error('Repeatable rows must be record objects.');
+        const id = row.id ?? row.record_id;
+        const identified =
+          (typeof id === 'string' && id.trim() !== '') ||
+          (typeof id === 'number' && Number.isFinite(id));
+        if (identified) {
+          const identity = `${typeof id}:${id}`;
+          if (identities.has(identity))
+            throw new Error(`Duplicate row identity in '${field.data_name}'.`);
+          identities.add(identity);
+        }
+        const segment = {
+          repeatableKey: info.preferredKey,
+          instanceId: identified ? id : null,
+          index,
+          identity: identified ? 'id' : 'position',
+        };
+        const visible =
+          record.visible?.[field.data_name] !== false &&
+          (template.chains.get(field.data_name) || []).every(
+            (name) => record.visible?.[name] !== false
+          );
+        walk(
+          row,
+          info.currentPath,
+          [...instancePath, segment],
+          [...ancestors, scope],
+          participating && visible
+        );
+      });
+    }
+  }
+  walk(snapshot, [], [], [], true);
+}