unspaghettit 0.2.0 → 0.4.0

package/src/features/behavior-model/domain/services/PersonaApplier.ts

@@ -1,39 +1,39 @@
-import type { Action } from '../entities/Action';
-import type { Persona } from '../entities/Persona';
-import type { ParameterValues } from './ParameterValidator';
-import { writePath, type StateSnapshot } from '../value-objects/StatePath';
-
-/**
- * Apply a persona's state overrides to a snapshot. State overrides are written
- * in declaration order so later overrides win on conflict. Matches the order
- * the user authored them.
- */
-export const applyPersonaToSnapshot = (
-  persona: Persona,
-  snapshot: StateSnapshot
-): StateSnapshot => {
-  let next = snapshot;
-  for (const override of persona.stateOverrides) {
-    next = writePath(next, override.path, override.value);
-  }
-  return next;
-};
-
-/**
- * Auto-fill action parameters from the persona by name. Existing values in
- * `current` (e.g. typed in by the user) win over persona defaults.
- */
-export const applyPersonaToParameters = (
-  persona: Persona,
-  action: Action,
-  current: ParameterValues
-): ParameterValues => {
-  const fromPersona: { [k: string]: ParameterValues[string] } = {};
-  const paramNames = new Set(action.parameters.map((p) => p.name));
-  for (const override of persona.parameterOverrides) {
-    if (paramNames.has(override.parameterName)) {
-      fromPersona[override.parameterName] = override.value;
-    }
-  }
-  return { ...fromPersona, ...current };
-};
+import type { Action } from '../entities/Action';
+import type { Persona } from '../entities/Persona';
+import type { ParameterValues } from './ParameterValidator';
+import { writePath, type StateSnapshot } from '../value-objects/StatePath';
+
+/**
+ * Apply a persona's state overrides to a snapshot. State overrides are written
+ * in declaration order so later overrides win on conflict. Matches the order
+ * the user authored them.
+ */
+export const applyPersonaToSnapshot = (
+  persona: Persona,
+  snapshot: StateSnapshot
+): StateSnapshot => {
+  let next = snapshot;
+  for (const override of persona.stateOverrides) {
+    next = writePath(next, override.path, override.value);
+  }
+  return next;
+};
+
+/**
+ * Auto-fill action parameters from the persona by name. Existing values in
+ * `current` (e.g. typed in by the user) win over persona defaults.
+ */
+export const applyPersonaToParameters = (
+  persona: Persona,
+  action: Action,
+  current: ParameterValues
+): ParameterValues => {
+  const fromPersona: { [k: string]: ParameterValues[string] } = {};
+  const paramNames = new Set(action.parameters.map((p) => p.name));
+  for (const override of persona.parameterOverrides) {
+    if (paramNames.has(override.parameterName)) {
+      fromPersona[override.parameterName] = override.value;
+    }
+  }
+  return { ...fromPersona, ...current };
+};

package/src/features/behavior-model/domain/services/ResourceDeducer.ts

@@ -1,64 +1,64 @@
-import type { Feature } from '../entities/Feature';
-import { humanizeStatePath } from '../value-objects/humanize';
-
-export type DeducedResourceCandidate = {
-  /** The Entity namespace this resource would back. */
-  readonly namespace: string;
-  readonly proposedName: string;
-  readonly reason: string;
-};
-
-const capitalize = (s: string): string =>
-  s.length === 0 ? s : s.charAt(0).toUpperCase() + s.slice(1);
-
-/**
- * Deduce Resource candidates from the model. The heuristic: every Entity
- * namespace that has fields but no `resourceId` is a hint that the data
- * needs a place to live. Plus every state-path namespace that exists at
- * runtime but has no Entity entity AND no resource. Also surfaced as a
- * suggestion.
- */
-export const deduceResourceCandidates = (
-  feature: Feature
-): readonly DeducedResourceCandidate[] => {
-  const candidates: DeducedResourceCandidate[] = [];
-  const seen = new Set<string>();
-
-  for (const data of feature.entities) {
-    if (data.resourceId) continue;
-    if (data.fields.length === 0) continue;
-    if (seen.has(data.namespace)) continue;
-    seen.add(data.namespace);
-    const displayName = capitalize(humanizeStatePath(data.namespace));
-    candidates.push({
-      namespace: data.namespace,
-      proposedName: displayName,
-      reason: `Entity entity "${displayName}" has ${data.fields.length} field${
-        data.fields.length === 1 ? '' : 's'
-      } but no backing resource.`
-    });
-  }
-
-  // Also flag bare state namespaces that have no Entity entity yet but are in use.
-  const dataNamespaces = new Set(feature.entities.map((d) => d.namespace));
-  const usedNamespaces = new Map<string, number>();
-  for (const surface of feature.surfaces) {
-    for (const def of surface.stateDefinitions) {
-      const ns = def.path.split('.')[0] ?? def.path;
-      usedNamespaces.set(ns, (usedNamespaces.get(ns) ?? 0) + 1);
-    }
-  }
-  for (const [namespace, count] of usedNamespaces) {
-    if (dataNamespaces.has(namespace)) continue;
-    if (seen.has(namespace)) continue;
-    seen.add(namespace);
-    candidates.push({
-      namespace,
-      proposedName: capitalize(humanizeStatePath(namespace)),
-      reason: `${count} state field${count === 1 ? '' : 's'} use the "${namespace}" namespace, but no resource catalogues where they live.`
-    });
-  }
-
-  candidates.sort((a, b) => a.namespace.localeCompare(b.namespace));
-  return candidates;
-};
+import type { Feature } from '../entities/Feature';
+import { humanizeStatePath } from '../value-objects/humanize';
+
+export type DeducedResourceCandidate = {
+  /** The Entity namespace this resource would back. */
+  readonly namespace: string;
+  readonly proposedName: string;
+  readonly reason: string;
+};
+
+const capitalize = (s: string): string =>
+  s.length === 0 ? s : s.charAt(0).toUpperCase() + s.slice(1);
+
+/**
+ * Deduce Resource candidates from the model. The heuristic: every Entity
+ * namespace that has fields but no `resourceId` is a hint that the data
+ * needs a place to live. Plus every state-path namespace that exists at
+ * runtime but has no Entity entity AND no resource. Also surfaced as a
+ * suggestion.
+ */
+export const deduceResourceCandidates = (
+  feature: Feature
+): readonly DeducedResourceCandidate[] => {
+  const candidates: DeducedResourceCandidate[] = [];
+  const seen = new Set<string>();
+
+  for (const data of feature.entities) {
+    if (data.resourceId) continue;
+    if (data.fields.length === 0) continue;
+    if (seen.has(data.namespace)) continue;
+    seen.add(data.namespace);
+    const displayName = capitalize(humanizeStatePath(data.namespace));
+    candidates.push({
+      namespace: data.namespace,
+      proposedName: displayName,
+      reason: `Entity entity "${displayName}" has ${data.fields.length} field${
+        data.fields.length === 1 ? '' : 's'
+      } but no backing resource.`
+    });
+  }
+
+  // Also flag bare state namespaces that have no Entity entity yet but are in use.
+  const dataNamespaces = new Set(feature.entities.map((d) => d.namespace));
+  const usedNamespaces = new Map<string, number>();
+  for (const surface of feature.surfaces) {
+    for (const def of surface.stateDefinitions) {
+      const ns = def.path.split('.')[0] ?? def.path;
+      usedNamespaces.set(ns, (usedNamespaces.get(ns) ?? 0) + 1);
+    }
+  }
+  for (const [namespace, count] of usedNamespaces) {
+    if (dataNamespaces.has(namespace)) continue;
+    if (seen.has(namespace)) continue;
+    seen.add(namespace);
+    candidates.push({
+      namespace,
+      proposedName: capitalize(humanizeStatePath(namespace)),
+      reason: `${count} state field${count === 1 ? '' : 's'} use the "${namespace}" namespace, but no resource catalogues where they live.`
+    });
+  }
+
+  candidates.sort((a, b) => a.namespace.localeCompare(b.namespace));
+  return candidates;
+};

package/src/features/behavior-model/domain/services/ResourceUsage.ts

@@ -1,79 +1,79 @@
-import type { Feature } from '../entities/Feature';
-import type { ResourceId } from '../value-objects/ids';
-
-/**
- * A action parameter that points at a resource via `resourceId`.
- */
-export type ResourceParameterUsage = {
-  readonly surfaceId: string;
-  readonly surfaceName: string;
-  readonly actionId: string;
-  readonly actionName: string;
-  readonly parameterId: string;
-  readonly parameterName: string;
-  readonly parameterType: string;
-};
-
-/**
- * Aggregate view of "what touches this resource", deduced from the model.
- * Used by the Resources tab to show, per resource, which Entity entities are
- * stored there and which action parameters read or write it.
- */
-export type ResourceUsage = {
-  readonly resourceId: string;
-  readonly dataNamespaces: readonly string[];
-  readonly parameters: readonly ResourceParameterUsage[];
-};
-
-export const buildResourceUsage = (
-  feature: Feature,
-  resourceId: ResourceId | string
-): ResourceUsage => {
-  const target = String(resourceId);
-
-  const dataNamespaces: string[] = [];
-  for (const data of feature.entities) {
-    if (data.resourceId && String(data.resourceId) === target) {
-      dataNamespaces.push(data.namespace);
-    }
-  }
-
-  const parameters: ResourceParameterUsage[] = [];
-  for (const surface of feature.surfaces) {
-    for (const cap of surface.actions) {
-      for (const param of cap.parameters) {
-        if (param.resourceId && String(param.resourceId) === target) {
-          parameters.push({
-            surfaceId: surface.id as unknown as string,
-            surfaceName: surface.name,
-            actionId: cap.id as unknown as string,
-            actionName: cap.name,
-            parameterId: param.id as unknown as string,
-            parameterName: param.name,
-            parameterType: param.type
-          });
-        }
-      }
-    }
-  }
-
-  parameters.sort((a, b) => {
-    if (a.surfaceName !== b.surfaceName) {
-      return a.surfaceName.localeCompare(b.surfaceName);
-    }
-    if (a.actionName !== b.actionName) {
-      return a.actionName.localeCompare(b.actionName);
-    }
-    return a.parameterName.localeCompare(b.parameterName);
-  });
-  dataNamespaces.sort();
-
-  return {
-    resourceId: target,
-    dataNamespaces,
-    parameters
-  };
-};
-
-export const totalUsage = (usage: ResourceUsage): number =>
-  usage.dataNamespaces.length + usage.parameters.length;
+import type { Feature } from '../entities/Feature';
+import type { ResourceId } from '../value-objects/ids';
+
+/**
+ * A action parameter that points at a resource via `resourceId`.
+ */
+export type ResourceParameterUsage = {
+  readonly surfaceId: string;
+  readonly surfaceName: string;
+  readonly actionId: string;
+  readonly actionName: string;
+  readonly parameterId: string;
+  readonly parameterName: string;
+  readonly parameterType: string;
+};
+
+/**
+ * Aggregate view of "what touches this resource", deduced from the model.
+ * Used by the Resources tab to show, per resource, which Entity entities are
+ * stored there and which action parameters read or write it.
+ */
+export type ResourceUsage = {
+  readonly resourceId: string;
+  readonly dataNamespaces: readonly string[];
+  readonly parameters: readonly ResourceParameterUsage[];
+};
+
+export const buildResourceUsage = (
+  feature: Feature,
+  resourceId: ResourceId | string
+): ResourceUsage => {
+  const target = String(resourceId);
+
+  const dataNamespaces: string[] = [];
+  for (const data of feature.entities) {
+    if (data.resourceId && String(data.resourceId) === target) {
+      dataNamespaces.push(data.namespace);
+    }
+  }
+
+  const parameters: ResourceParameterUsage[] = [];
+  for (const surface of feature.surfaces) {
+    for (const cap of surface.actions) {
+      for (const param of cap.parameters) {
+        if (param.resourceId && String(param.resourceId) === target) {
+          parameters.push({
+            surfaceId: surface.id as unknown as string,
+            surfaceName: surface.name,
+            actionId: cap.id as unknown as string,
+            actionName: cap.name,
+            parameterId: param.id as unknown as string,
+            parameterName: param.name,
+            parameterType: param.type
+          });
+        }
+      }
+    }
+  }
+
+  parameters.sort((a, b) => {
+    if (a.surfaceName !== b.surfaceName) {
+      return a.surfaceName.localeCompare(b.surfaceName);
+    }
+    if (a.actionName !== b.actionName) {
+      return a.actionName.localeCompare(b.actionName);
+    }
+    return a.parameterName.localeCompare(b.parameterName);
+  });
+  dataNamespaces.sort();
+
+  return {
+    resourceId: target,
+    dataNamespaces,
+    parameters
+  };
+};
+
+export const totalUsage = (usage: ResourceUsage): number =>
+  usage.dataNamespaces.length + usage.parameters.length;

package/src/features/behavior-model/domain/services/ScenarioApplier.ts

@@ -1,40 +1,40 @@
-import type { Action } from '../entities/Action';
-import type { Scenario } from '../entities/Scenario';
-import type { ParameterValues } from './ParameterValidator';
-import { writePath, type StateSnapshot } from '../value-objects/StatePath';
-
-/**
- * Apply a scenario's state overrides to the given snapshot. Overrides are
- * written in declaration order so later entries win on conflict. Matches
- * the order the modeler authored them.
- */
-export const applyScenarioToSnapshot = (
-  scenario: Scenario,
-  snapshot: StateSnapshot
-): StateSnapshot => {
-  let next = snapshot;
-  for (const override of scenario.stateOverrides) {
-    next = writePath(next, override.path, override.value);
-  }
-  return next;
-};
-
-/**
- * Auto-fill action parameters from a scenario by name. Existing values in
- * `current` (e.g. typed in by the user, or set by a persona) win over scenario
- * defaults. The scenario only fills slots that aren't already populated.
- */
-export const applyScenarioToParameters = (
-  scenario: Scenario,
-  action: Action,
-  current: ParameterValues
-): ParameterValues => {
-  const fromScenario: { [k: string]: ParameterValues[string] } = {};
-  const paramNames = new Set(action.parameters.map((p) => p.name));
-  for (const override of scenario.parameterOverrides) {
-    if (paramNames.has(override.parameterName)) {
-      fromScenario[override.parameterName] = override.value;
-    }
-  }
-  return { ...fromScenario, ...current };
-};
+import type { Action } from '../entities/Action';
+import type { Scenario } from '../entities/Scenario';
+import type { ParameterValues } from './ParameterValidator';
+import { writePath, type StateSnapshot } from '../value-objects/StatePath';
+
+/**
+ * Apply a scenario's state overrides to the given snapshot. Overrides are
+ * written in declaration order so later entries win on conflict. Matches
+ * the order the modeler authored them.
+ */
+export const applyScenarioToSnapshot = (
+  scenario: Scenario,
+  snapshot: StateSnapshot
+): StateSnapshot => {
+  let next = snapshot;
+  for (const override of scenario.stateOverrides) {
+    next = writePath(next, override.path, override.value);
+  }
+  return next;
+};
+
+/**
+ * Auto-fill action parameters from a scenario by name. Existing values in
+ * `current` (e.g. typed in by the user, or set by a persona) win over scenario
+ * defaults. The scenario only fills slots that aren't already populated.
+ */
+export const applyScenarioToParameters = (
+  scenario: Scenario,
+  action: Action,
+  current: ParameterValues
+): ParameterValues => {
+  const fromScenario: { [k: string]: ParameterValues[string] } = {};
+  const paramNames = new Set(action.parameters.map((p) => p.name));
+  for (const override of scenario.parameterOverrides) {
+    if (paramNames.has(override.parameterName)) {
+      fromScenario[override.parameterName] = override.value;
+    }
+  }
+  return { ...fromScenario, ...current };
+};

package/src/features/behavior-model/domain/services/SharedStateDefinitions.ts

@@ -1,32 +1,32 @@
-import type { Feature } from '../entities/Feature';
-import type { StateDefinition } from '../entities/StateDefinition';
-import type { Surface } from '../entities/Surface';
-
-export const getStateDefinitionsForSurface = (
-  feature: Feature,
-  surface: Surface
-): readonly StateDefinition[] => {
-  const byPath = new Map<string, StateDefinition>();
-  for (const def of surface.stateDefinitions) {
-    byPath.set(String(def.path), def);
-  }
-
-  for (const other of feature.surfaces) {
-    if (other.id === surface.id) continue;
-    for (const def of other.stateDefinitions) {
-      if (!def.sharedWith?.includes(surface.id)) continue;
-      const path = String(def.path);
-      if (!byPath.has(path)) byPath.set(path, def);
-    }
-  }
-
-  return [...byPath.values()];
-};
-
-export const withSharedStateDefinitions = (
-  feature: Feature,
-  surface: Surface
-): Surface => ({
-  ...surface,
-  stateDefinitions: getStateDefinitionsForSurface(feature, surface)
-});
+import type { Feature } from '../entities/Feature';
+import type { StateDefinition } from '../entities/StateDefinition';
+import type { Surface } from '../entities/Surface';
+
+export const getStateDefinitionsForSurface = (
+  feature: Feature,
+  surface: Surface
+): readonly StateDefinition[] => {
+  const byPath = new Map<string, StateDefinition>();
+  for (const def of surface.stateDefinitions) {
+    byPath.set(String(def.path), def);
+  }
+
+  for (const other of feature.surfaces) {
+    if (other.id === surface.id) continue;
+    for (const def of other.stateDefinitions) {
+      if (!def.sharedWith?.includes(surface.id)) continue;
+      const path = String(def.path);
+      if (!byPath.has(path)) byPath.set(path, def);
+    }
+  }
+
+  return [...byPath.values()];
+};
+
+export const withSharedStateDefinitions = (
+  feature: Feature,
+  surface: Surface
+): Surface => ({
+  ...surface,
+  stateDefinitions: getStateDefinitionsForSurface(feature, surface)
+});