@rohal12/spindle 0.59.11 → 0.59.13

package/src/utils/control-edits.ts

@@ -0,0 +1,48 @@
+import { getByPath } from './object-path';
+
+/**
+ * Records the edits a reader made through a control bound to a story
+ * variable (`{textbox}`, `{checkbox}`, ...). {for} tells these apart from a
+ * list that is replaced: typing into a control inside an iteration changes
+ * its item, but must not remount the iteration and drop the control's focus.
+ * An edit is attributed to the variable path it wrote, so a replacement made
+ * elsewhere (a watcher reacting to the edit) still remounts.
+ */
+let version = 0;
+const MAX_LOG = 256;
+const log: { version: number; segments: readonly string[] }[] = [];
+
+export function noteControlEdit(segments: readonly string[]): void {
+  log.push({ version: ++version, segments });
+  if (log.length > MAX_LOG) log.shift();
+}
+
+export function controlEditVersion(): number {
+  return version;
+}
+
+/**
+ * Whether an edit since `since` wrote inside `item`, element `index` of
+ * `list`: the path leads through the item (compared by reference in
+ * `variables`), or, for a primitive item, ends at its slot in the list.
+ */
+export function editedItem(
+  since: number,
+  variables: object,
+  list: readonly unknown[],
+  item: unknown,
+  index: number,
+): boolean {
+  return log.some(({ version: v, segments }) => {
+    if (v <= since) return false;
+    if (typeof item === 'object' && item !== null) {
+      return segments.some(
+        (_, n) => getByPath(variables, segments.slice(0, n + 1)) === item,
+      );
+    }
+    return (
+      segments[segments.length - 1] === String(index) &&
+      getByPath(variables, segments.slice(0, -1)) === list
+    );
+  });
+}

package/src/widgets/register-widget-def.ts

@@ -0,0 +1,44 @@
+import { registerWidget } from './widget-registry';
+import { astContainsChildren } from './ast-scanner';
+import { registerBlockMacro, type ASTNode } from '../markup/ast';
+import { errorMessage } from '../utils/error-message';
+import { parseWidgetDef, type WidgetDef } from './widget-def';
+
+/**
+ * Register the widget a definition declares, with its body. Widgets whose
+ * body renders {@children} take a closing tag, so they are registered as
+ * block macros too: passages parsed later nest their content. A parameter
+ * that no namespace can hold throws (see registerWidget), registering
+ * nothing.
+ */
+export function registerWidgetDef(
+  { name, params }: WidgetDef,
+  body: ASTNode[],
+): void {
+  const isBlock = astContainsChildren(body);
+  registerWidget(name, body, params, isBlock);
+  if (isBlock) registerBlockMacro(name);
+}
+
+/**
+ * Register the widgets `nodes` (a passage's markup) define at its top level,
+ * as the {widget} macro does when it renders. A widget that fails to register
+ * is reported; the others still register.
+ */
+export function registerWidgetDefinitions(
+  nodes: ASTNode[],
+  passageName: string,
+): void {
+  for (const node of nodes) {
+    if (node.type === 'macro' && node.name === 'widget' && node.rawArgs) {
+      const def = parseWidgetDef(node.rawArgs);
+      try {
+        registerWidgetDef(def, node.children as ASTNode[]);
+      } catch (err) {
+        console.error(
+          `spindle: widget "${def.name}" in passage "${passageName}" was not registered: ${errorMessage(err)}`,
+        );
+      }
+    }
+  }
+}

package/types/tooling.d.ts

@@ -100,7 +100,13 @@ export declare function defineMacro(config: MacroDefinition): void;
 export declare function getMacroRegistry(): MacroMetadata[];
 
 /** Variable type inferred from a StoryVariables/StoryTransients default value. */
-export type VarType = 'number' | 'string' | 'boolean' | 'array' | 'object';
+export type VarType =
+  | 'number'
+  | 'string'
+  | 'boolean'
+  | 'array'
+  | 'object'
+  | 'null';
 
 /** Inferred shape of a declared variable (or one of its object fields). */
 export interface FieldSchema {