form0-core 0.6.0 → 0.8.0

package/src/engine/managed-events.js

@@ -1,6 +1,7 @@
 import { getEventInfo, isValidEventType } from './event-registry.js';
 import { closeEventOperationScope, createEventOperationScope } from './event-operation-scope.js';
 import { getEventFieldReferences } from './event-field-references.js';
+import { eventOperationIssue, reportEventOperationIssue } from './event-policy.js';
 
 // Portable defensive copies also work in runtimes without structuredClone (including Hermes).
 function copy(value, seen = new Map()) {
@@ -30,25 +31,38 @@ 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) {
+export function createManagedEventDispatcher(manager, constructionScope, getMode = () => 'edit') {
   const instancePath = copy(constructionScope?.instancePath);
   const scopeId = constructionScope?.scopeId;
   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,8 +84,10 @@ 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 mode = getMode();
     const result = { operations: [], validationIssues: [], issues: [] };
     const issue = (code, message) =>
       result.issues.push({
@@ -122,13 +138,13 @@ export function createManagedEventDispatcher(manager, constructionScope) {
         timestamp: Date.now(),
         instancePath: copy(instancePath),
         scopeId,
+        mode,
       };
     } catch {
       issue('invalid_request', 'Event metadata must contain portable data.');
       return result;
     }
-    const validation = eventType === 'validate-record' || eventType === 'validate-repeatable';
-    const closing = /^(cancel|unload)-/.test(eventType);
+    const registrations = [];
     const eventMap = manager.listeners.get(eventType);
     const listeners = [...(eventMap?.get(fieldKey) || []), ...(eventMap?.get('*') || [])];
     for (const callback of listeners) {
@@ -149,8 +165,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);
@@ -194,26 +214,31 @@ export function createManagedEventDispatcher(manager, constructionScope) {
         collected = closeEventOperationScope(scope);
       }
       try {
-        if (returned?.type === 'UI_OPERATION' && !collected.includes(returned))
+        if (
+          typeof returned?.type === 'string' &&
+          returned.type.endsWith('_OPERATION') &&
+          !collected.includes(returned)
+        )
           collected.push(copy(returned));
       } catch {
         issue('invalid_operation', 'The returned event operation must contain portable data.');
       }
       for (const operation of collected) {
-        if (operation?.type === 'EVENT_OPERATION') continue;
-        if (operation?.operation === 'INVALID') {
-          if (!validation)
-            issue('invalid_context', 'INVALID() is only available during managed validation.');
-          else
-            result.validationIssues.push({
-              message: operation.params.message,
-              instancePath: copy(instancePath),
-            });
-        } else if (validation || closing) {
-          issue(
-            'operation_not_allowed',
-            'Validation and close handlers cannot perform value or UI operations.'
-          );
+        const rejected = eventOperationIssue(operation, mode, eventType);
+        if (rejected) {
+          issue(rejected.code, rejected.message);
+          if (
+            rejected.code === 'readonly_operation_not_allowed' ||
+            rejected.code === 'invalid_operation'
+          )
+            reportEventOperationIssue(manager.warningSystem, rejected, eventType);
+        } else if (operation.type === 'EVENT_OPERATION') {
+          registrations.push(operation);
+        } else if (operation.operation === 'INVALID') {
+          result.validationIssues.push({
+            message: operation.params.message,
+            instancePath: copy(instancePath),
+          });
         } else if (operation?.type === 'FIELD_OPERATION' && operation.operation === 'SETVALUE') {
           const field = fields.get(operation.params?.fieldDataName);
           if (!field || !same(field.parentPath))
@@ -239,6 +264,7 @@ export function createManagedEventDispatcher(manager, constructionScope) {
     }
     // A failed managed dispatch is not a partially applicable operation batch.
     if (result.issues.length) result.operations = [];
+    else manager.processEventOperations(registrations);
     return copy(result);
   };
 }

package/src/engine/record-context.js

@@ -0,0 +1,133 @@
+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) {
+  for (const scope of iterateRecordScopes(snapshot, context)) visit(scope);
+}
+
+/** Same traversal for synchronous validation and budgeted private-tree preparation. */
+export function* iterateRecordScopes(snapshot, context) {
+  function* walk(record, path, instancePath, ancestors, participating) {
+    const template = context.templates.get(JSON.stringify(path));
+    const scope = { record, template, instancePath, ancestors, participating };
+    yield 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();
+      for (let index = 0; index < rows.length; index++) {
+        if (!(index in rows)) continue;
+        const row = rows[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
+          );
+        yield* walk(
+          row,
+          info.currentPath,
+          [...instancePath, segment],
+          [...ancestors, scope],
+          participating && visible
+        );
+      }
+    }
+  }
+  yield* walk(snapshot, [], [], [], true);
+}