@rohal12/spindle 0.52.7 → 0.52.8

package/src/interpolation.ts

@@ -27,6 +27,7 @@ import { getMacro, getMacroText, isSubMacro } from './registry';
 import type { MacroTextContext } from './registry';
 import { getWidget } from './widgets/widget-registry';
 import { splitArgs } from './components/macros/arg-utils';
+import { display } from './components/macros/display';
 import { splitSigilTemplate } from './markup/code-attributes';
 import {
   checkVariableName,
@@ -118,10 +119,6 @@ export function mapTextNodes(
 /** Deep enough for any real nesting; stops a widget that includes itself. */
 const MAX_DEPTH = 100;
 
-function display(value: unknown): string {
-  return value == null ? '' : String(value);
-}
-
 /**
  * The value of a variable reference (`name` without its sigil, with an
  * optional dot path), as `{$name}` shows it in passage text (see
@@ -154,6 +151,17 @@ function resolveVariable(
   return value;
 }
 
+/** Evaluate an expression in `scope`. */
+function evaluateIn(expr: string, scope: TextScope): unknown {
+  return evaluate(
+    expr,
+    scope.variables,
+    scope.temporary,
+    scope.locals,
+    scope.transient,
+  );
+}
+
 class TextEvaluator {
   readonly errors: TextError[] = [];
 
@@ -163,16 +171,6 @@ class TextEvaluator {
     return text;
   }
 
-  private evaluate(expr: string, scope: TextScope): unknown {
-    return evaluate(
-      expr,
-      scope.variables,
-      scope.temporary,
-      scope.locals,
-      scope.transient,
-    );
-  }
-
   private node(node: ASTNode, scope: TextScope, depth: number): string {
     switch (node.type) {
       case 'text':
@@ -190,7 +188,7 @@ class TextEvaluator {
         return this.variable(node.scope, node.name, scope);
       case 'expression':
         try {
-          return display(this.evaluate(node.expression, scope));
+          return display(evaluateIn(node.expression, scope));
         } catch (error) {
           this.errors.push({ macro: 'expression', error });
           return '';
@@ -255,7 +253,7 @@ class TextEvaluator {
           const expr = argExprs[i];
           if (expr !== undefined) {
             try {
-              value = this.evaluate(expr, scope);
+              value = evaluateIn(expr, scope);
             } catch {
               value = undefined;
             }
@@ -279,7 +277,7 @@ class TextEvaluator {
     }
 
     const ctx: MacroTextContext = {
-      evaluate: (expr) => this.evaluate(expr, scope),
+      evaluate: (expr) => evaluateIn(expr, scope),
       renderText: (nodes, locals) =>
         this.nested(
           node.name,
@@ -369,15 +367,7 @@ export function interpolateCode(
       }
     } else {
       try {
-        text += display(
-          evaluate(
-            part.expr,
-            scope.variables,
-            scope.temporary,
-            scope.locals,
-            scope.transient,
-          ),
-        );
+        text += display(evaluateIn(part.expr, scope));
       } catch (error) {
         errors.push({ macro: 'expression', error });
       }
@@ -386,22 +376,28 @@ export function interpolateCode(
   return { text, errors };
 }
 
+/** The namespaces of a TextScope, passed one by one. */
+type ScopeArgs = [
+  variables: Record<string, unknown>,
+  temporary: Record<string, unknown>,
+  locals: Record<string, unknown>,
+  transient?: Record<string, unknown>,
+];
+
+function scopeOf(
+  ...[variables, temporary, locals, transient = {}]: ScopeArgs
+): TextScope {
+  return { variables, temporary, locals, transient };
+}
+
 /**
  * Evaluate text-only markup to a string, throwing the first error met.
  */
 export function interpolate(
   template: string,
-  variables: Record<string, unknown>,
-  temporary: Record<string, unknown>,
-  locals: Record<string, unknown>,
-  transient: Record<string, unknown> = {},
+  ...namespaces: ScopeArgs
 ): string {
-  const { text, errors } = interpolateText(template, {
-    variables,
-    temporary,
-    locals,
-    transient,
-  });
+  const { text, errors } = interpolateText(template, scopeOf(...namespaces));
   if (errors.length > 0) throw errors[0]!.error;
   return text;
 }
@@ -412,10 +408,7 @@ export function interpolate(
  */
 export function interpolateExpression(
   expr: string,
-  variables: Record<string, unknown>,
-  temporary: Record<string, unknown>,
-  locals: Record<string, unknown>,
-  transient: Record<string, unknown> = {},
+  ...namespaces: ScopeArgs
 ): string {
-  return display(evaluate(expr, variables, temporary, locals, transient));
+  return display(evaluateIn(expr, scopeOf(...namespaces)));
 }

package/src/markup/ast.ts

@@ -6,6 +6,7 @@ import {
   type Token,
   type VariableScope,
 } from './tokenizer';
+import { NameSet } from '../utils/macro-names';
 
 export interface TextNode {
   type: 'text';
@@ -51,7 +52,7 @@ export type ASTNode =
   | HtmlNode;
 
 /** Macros that require a closing tag and can contain children */
-const BLOCK_MACROS = new Set([
+const BLOCK_MACROS = new NameSet([
   'if',
   'for',
   'do',
@@ -70,12 +71,12 @@ const BLOCK_MACROS = new Set([
 
 /** Register a custom macro as a block macro so the AST builder nests children. */
 export function registerBlockMacro(name: string): void {
-  BLOCK_MACROS.add(name.toLowerCase());
+  BLOCK_MACROS.add(name);
 }
 
 /** Unregister a custom block macro (for test cleanup). */
 export function unregisterBlockMacro(name: string): void {
-  BLOCK_MACROS.delete(name.toLowerCase());
+  BLOCK_MACROS.delete(name);
 }
 
 /** Map from branch macro name → required parent macro name */

package/src/markup/render.tsx

@@ -588,12 +588,9 @@ function HtmlNodeRenderer({ node }: { node: HtmlNode }) {
 
 function ChildrenSlot() {
   const childrenAST = useContext(WidgetChildrenContext);
-  const nobr = useContext(NobrContext);
-  const inline = useContext(InlineContext);
-  const raw = useContext(RawTextContext);
-  const locals = useContext(LocalsValuesContext);
+  const renderOptions = useRenderOptions();
   if (!childrenAST || childrenAST.length === 0) return null;
-  return <>{renderNodes(childrenAST, { nobr, locals, inline, raw })}</>;
+  return <>{renderNodes(childrenAST, renderOptions)}</>;
 }
 
 /**
@@ -669,10 +666,7 @@ function renderSingleNode(node: ASTNode): preact.ComponentChildren {
       return (
         <VarDisplay
           key={key}
-          name={node.name}
-          scope={node.scope}
-          className={node.className}
-          id={node.id}
+          node={node}
         />
       );
 
@@ -680,9 +674,7 @@ function renderSingleNode(node: ASTNode): preact.ComponentChildren {
       return (
         <ExprDisplay
           key={key}
-          expression={node.expression}
-          className={node.className}
-          id={node.id}
+          node={node}
         />
       );
 

package/src/registry.ts

@@ -1,5 +1,6 @@
 import type { ComponentType } from 'preact';
 import type { ASTNode, Branch } from './markup/ast';
+import { NameMap, NameSet } from './utils/macro-names';
 
 export interface MacroProps {
   rawArgs: string;
@@ -9,17 +10,17 @@ export interface MacroProps {
   branches?: Branch[];
 }
 
-const registry = new Map<string, ComponentType<MacroProps>>();
+const registry = new NameMap<ComponentType<MacroProps>>();
 
 export function registerMacro(
   name: string,
   component: ComponentType<MacroProps>,
 ): void {
-  registry.set(name.toLowerCase(), component);
+  registry.set(name, component);
 }
 
 export function getMacro(name: string): ComponentType<MacroProps> | undefined {
-  return registry.get(name.toLowerCase());
+  return registry.get(name);
 }
 
 /**
@@ -42,29 +43,29 @@ export type MacroTextRenderer = (
   ctx: MacroTextContext,
 ) => string;
 
-const textRegistry = new Map<string, MacroTextRenderer>();
+const textRegistry = new NameMap<MacroTextRenderer>();
 
 /** Register (or, with undefined, remove) the text form of a macro. */
 export function registerMacroText(
   name: string,
   text: MacroTextRenderer | undefined,
 ): void {
-  if (text) textRegistry.set(name.toLowerCase(), text);
-  else textRegistry.delete(name.toLowerCase());
+  if (text) textRegistry.set(name, text);
+  else textRegistry.delete(name);
 }
 
 export function getMacroText(name: string): MacroTextRenderer | undefined {
-  return textRegistry.get(name.toLowerCase());
+  return textRegistry.get(name);
 }
 
-const subMacros = new Set<string>();
+const subMacros = new NameSet();
 
 export function registerSubMacro(name: string): void {
-  subMacros.add(name.toLowerCase());
+  subMacros.add(name);
 }
 
 export function isSubMacro(name: string): boolean {
-  return subMacros.has(name.toLowerCase());
+  return subMacros.has(name);
 }
 
 /**
@@ -133,13 +134,13 @@ export interface MacroMetadata {
   parameters?: ParameterDef[];
 }
 
-const metadataRegistry = new Map<string, MacroMetadata>();
+const metadataRegistry = new NameMap<MacroMetadata>();
 
 export function registerMacroMetadata(
   name: string,
   metadata: MacroMetadata,
 ): void {
-  metadataRegistry.set(name.toLowerCase(), metadata);
+  metadataRegistry.set(name, metadata);
 }
 
 export function getMacroRegistry(): MacroMetadata[] {

package/src/saves/save-manager.ts

@@ -9,7 +9,8 @@ import type {
 } from './types';
 import { estimatePayloadBytes, isSaveExport, isSavePayload } from './types';
 import { getBackend, resetBackend } from './storage';
-import { deepClone, serialize, deserialize } from '../class-registry';
+import { serialize, deserialize } from '../class-registry';
+import { deepClone } from '../structural';
 import { emit } from '../event-emitter';
 import { withoutDraws } from '../prng';
 
@@ -101,6 +102,18 @@ function queued<A extends unknown[], R>(
   return (...args) => inOrder(() => op(...args));
 }
 
+/** An operation passing the save `saveId`, if it is stored, to `read`. */
+const readingSave = <R>(read: (record: SaveRecord | undefined) => R) =>
+  queued(async (saveId: string) =>
+    read(await (await getBackend()).getSave(saveId)),
+  );
+
+/** An operation passing the save a slot holds, if any, to `read`. */
+const readingSlot = <R>(read: (record: SaveRecord | undefined) => R) =>
+  queued(async (ifid: string, slot?: string) =>
+    read(await slotRecord(ifid, slot)),
+  );
+
 // --- Playthroughs ---
 
 /**
@@ -371,9 +384,7 @@ export function deserializePayload(payload: SavePayload): SavePayload {
 const livePayload = (record: SaveRecord | undefined) =>
   record && deserializePayload(record.payload);
 
-export const loadSave = queued(async (saveId: string) =>
-  livePayload(await (await getBackend()).getSave(saveId)),
-);
+export const loadSave = readingSave(livePayload);
 
 /**
  * Delete a save record. If the default slot or a named slot holds it, that
@@ -623,9 +634,7 @@ async function hasQuickSaveNow(ifid: string, slot?: string): Promise<boolean> {
   return (await slotRecord(ifid, slot)) !== undefined;
 }
 
-export const loadQuickSave = queued(async (ifid: string, slot?: string) =>
-  livePayload(await slotRecord(ifid, slot)),
-);
+export const loadQuickSave = readingSlot(livePayload);
 
 /**
  * Read the save held in a slot (the default slot when `slot` is omitted) for
@@ -753,9 +762,7 @@ function toExport(record: SaveRecord | undefined): SaveExport | undefined {
   };
 }
 
-export const exportSave = queued(async (saveId: string) =>
-  toExport(await (await getBackend()).getSave(saveId)),
-);
+export const exportSave = readingSave(toExport);
 
 /**
  * Validate an export against the running story and build the record to store:
@@ -812,9 +819,7 @@ export function importSave(
  * Export the save held in a slot (default autosave slot when `slot` is omitted).
  * Returns undefined if the slot is empty.
  */
-export const exportSlotSave = queued(async (ifid: string, slot?: string) =>
-  toExport(await slotRecord(ifid, slot)),
-);
+export const exportSlotSave = readingSlot(toExport);
 
 /**
  * Import an exported save into a slot (default autosave slot when `slot` is

package/src/saves/storage.ts

@@ -256,6 +256,19 @@ export function createLocalStorageBackend(): StorageBackend {
 const IDB_DB_NAME = 'spindle';
 const IDB_DB_VERSION = 1;
 
+/** Each object store's key path, and the key path of each of its indexes. */
+const IDB_STORES: Record<
+  TableName,
+  { keyPath: string; indexes: Record<string, string> }
+> = {
+  saves: {
+    keyPath: 'meta.id',
+    indexes: { ifid: 'meta.ifid', playthroughId: 'meta.playthroughId' },
+  },
+  playthroughs: { keyPath: 'id', indexes: { ifid: 'ifid' } },
+  meta: { keyPath: 'key', indexes: {} },
+};
+
 function createIDBBackend(): StorageBackend {
   let dbPromise: Promise<IDBDatabase> | null = null;
 
@@ -267,26 +280,12 @@ function createIDBBackend(): StorageBackend {
 
       req.onupgradeneeded = () => {
         const db = req.result;
-
-        if (!db.objectStoreNames.contains('saves')) {
-          const savesStore = db.createObjectStore('saves', {
-            keyPath: 'meta.id',
-          });
-          savesStore.createIndex('ifid', 'meta.ifid', { unique: false });
-          savesStore.createIndex('playthroughId', 'meta.playthroughId', {
-            unique: false,
-          });
-        }
-
-        if (!db.objectStoreNames.contains('playthroughs')) {
-          const ptStore = db.createObjectStore('playthroughs', {
-            keyPath: 'id',
-          });
-          ptStore.createIndex('ifid', 'ifid', { unique: false });
-        }
-
-        if (!db.objectStoreNames.contains('meta')) {
-          db.createObjectStore('meta', { keyPath: 'key' });
+        for (const [name, { keyPath, indexes }] of Object.entries(IDB_STORES)) {
+          if (db.objectStoreNames.contains(name)) continue;
+          const store = db.createObjectStore(name, { keyPath });
+          for (const [index, path] of Object.entries(indexes)) {
+            store.createIndex(index, path, { unique: false });
+          }
         }
       };
 

package/src/story-api.ts

@@ -1,5 +1,5 @@
 import { useStoryStore, trackRuntimeUnsub } from './store';
-import type { VariableNamespaces } from './store';
+import type { StoryState, VariableNamespaces } from './store';
 import {
   on as emitterOn,
   emit,
@@ -24,7 +24,7 @@ import { registerClass } from './class-registry';
 import { frozenCopy, getActiveMutationScope } from './execute-mutation';
 import { getByPath, setByPath } from './utils/object-path';
 import { changedNames, checkVariableName, ownValue } from './utils/namespace';
-import { countQueries, currentPassage, previousPassage } from './expression';
+import { historyQueries } from './expression';
 import { defineMacro } from './define-macro';
 import type { MacroDefinition } from './define-macro';
 import { getMacroRegistry as _getMacroRegistry } from './registry';
@@ -259,9 +259,15 @@ function setOne(draft: VariableNamespaces, name: string, value: unknown): void {
   }
 }
 
+/** A method calling the store action `name`, as the store holds it then. */
+function storeAction<K extends keyof StoryState>(name: K): StoryState[K] {
+  return ((...args: unknown[]) =>
+    (useStoryStore.getState()[name] as (...args: unknown[]) => unknown)(
+      ...args,
+    )) as StoryState[K];
+}
+
 function createStoryAPI(): StoryAPI {
-  const visits = countQueries(() => useStoryStore.getState().visitCounts);
-  const renders = countQueries(() => useStoryStore.getState().renderCounts);
   return {
     get(name: string): unknown {
       const { isTransient, key } = parseName(name);
@@ -300,64 +306,23 @@ function createStoryAPI(): StoryAPI {
     // Called from running mutation code, these store actions commit the
     // code's writes so far before they record, replace or save state, and
     // the code goes on from the state they leave (see storyStateGuard).
-    goto(passageName: string): void {
-      useStoryStore.getState().navigate(passageName);
-    },
-
-    back(): void {
-      useStoryStore.getState().goBack();
-    },
-
-    forward(): void {
-      useStoryStore.getState().goForward();
-    },
-
-    restart(): void {
-      useStoryStore.getState().restart();
-    },
-
-    save(slot?: string, custom?: Record<string, unknown>): Promise<void> {
-      return useStoryStore.getState().save(slot, custom);
-    },
-
-    load(slot?: string): Promise<void> {
-      return useStoryStore.getState().load(slot);
-    },
-
-    hasSave(slot?: string): boolean {
-      return useStoryStore.getState().hasSave(slot);
-    },
-
-    getSaveInfo(slot?: string): Promise<SaveInfo | null> {
-      return useStoryStore.getState().getSaveInfo(slot);
-    },
-
-    listSaves(): Promise<SaveInfo[]> {
-      return useStoryStore.getState().listSaves();
-    },
-
-    deleteSave(slot?: string): Promise<void> {
-      return useStoryStore.getState().deleteSave(slot);
-    },
-
-    exportSave(slot?: string): Promise<SaveExport | null> {
-      return useStoryStore.getState().exportSave(slot);
-    },
-
-    importSave(data: unknown, slot?: string): Promise<SaveInfo> {
-      return useStoryStore.getState().importSave(data, slot);
-    },
-
-    visited: visits.count,
-    hasVisited: visits.has,
-    hasVisitedAny: visits.any,
-    hasVisitedAll: visits.all,
-    rendered: renders.count,
-    hasRendered: renders.has,
-    hasRenderedAny: renders.any,
-    hasRenderedAll: renders.all,
-    currentPassage,
-    previousPassage,
+    goto: storeAction('navigate'),
+    back: storeAction('goBack'),
+    forward: storeAction('goForward'),
+    restart: storeAction('restart'),
+    save: storeAction('save'),
+    load: storeAction('load'),
+    hasSave: storeAction('hasSave'),
+    getSaveInfo: storeAction('getSaveInfo'),
+    listSaves: storeAction('listSaves'),
+    deleteSave: storeAction('deleteSave'),
+    exportSave: storeAction('exportSave'),
+    importSave: storeAction('importSave'),
+
+    ...historyQueries(
+      () => useStoryStore.getState().visitCounts,
+      () => useStoryStore.getState().renderCounts,
+    ),
 
     get title(): string {
       return useStoryStore.getState().storyData?.name || '';
@@ -416,17 +381,9 @@ function createStoryAPI(): StoryAPI {
         return { usage: 0, quota: 0, estimateSupported: false };
       },
 
-      clearGameData(): Promise<void> {
-        return useStoryStore.getState().clearGameData();
-      },
-
-      clearAllData(): Promise<void> {
-        return useStoryStore.getState().clearAllData();
-      },
-
-      deletePlaythrough(playthroughId: string): Promise<void> {
-        return useStoryStore.getState().deletePlaythrough(playthroughId);
-      },
+      clearGameData: storeAction('clearGameData'),
+      clearAllData: storeAction('clearAllData'),
+      deletePlaythrough: storeAction('deletePlaythrough'),
 
       get backend() {
         return getBackendType();

package/src/structural.ts

@@ -4,26 +4,9 @@
 // what a change is.
 
 import { registeredClassName } from './class-registry';
-import { hasOwn } from './utils/namespace';
+import { hasOwn, setOwn } from './utils/namespace';
 import { deleteByPath, getByPath, setByPath } from './utils/object-path';
 
-/**
- * Set an own enumerable property. A "__proto__" key is defined as an own
- * property (as JSON.parse does) instead of replacing the prototype.
- */
-export function setOwn(target: object, key: string, value: unknown): void {
-  if (key === '__proto__') {
-    Object.defineProperty(target, key, {
-      value,
-      enumerable: true,
-      writable: true,
-      configurable: true,
-    });
-  } else {
-    (target as Record<string, unknown>)[key] = value;
-  }
-}
-
 // --- Deep Clone ---
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {