@rohal12/spindle 0.16.1 → 0.18.1

package/src/define-macro.ts

@@ -0,0 +1,154 @@
+import { h, Fragment } from 'preact';
+import type { VNode, ComponentChildren } from 'preact';
+import {
+  useContext,
+  useState,
+  useRef,
+  useEffect,
+  useLayoutEffect,
+  useCallback,
+  useMemo,
+} from 'preact/hooks';
+import { useInterpolate } from './hooks/use-interpolate';
+import { useMergedLocals } from './hooks/use-merged-locals';
+import {
+  LocalsUpdateContext,
+  renderNodes,
+  renderInlineNodes,
+} from './markup/render';
+import { executeMutation } from './execute-mutation';
+import { evaluate } from './expression';
+import { useStoryStore } from './store';
+import { useAction } from './hooks/use-action';
+import type { UseActionOptions } from './hooks/use-action';
+import { collectText } from './utils/extract-text';
+import { currentSourceLocation } from './utils/source-location';
+import { parseVarArgs, extractOptions } from './components/macros/option-utils';
+import { registerMacro, registerSubMacro } from './registry';
+import type { MacroProps } from './registry';
+
+export function macroClass(type: string, className?: string): string {
+  const base = `macro-${type}`;
+  return className ? `${base} ${className}` : base;
+}
+
+export interface MacroContext {
+  className?: string;
+  id?: string;
+  resolve?: (s: string | undefined) => string | undefined;
+  cls: string;
+  mutate: (code: string) => void;
+  update: (key: string, value: unknown) => void;
+  getValues: () => Record<string, unknown>;
+  merged?: readonly [
+    Record<string, unknown>,
+    Record<string, unknown>,
+    Record<string, unknown>,
+  ];
+  varName?: string;
+  value?: unknown;
+  setValue?: (value: unknown) => void;
+  evaluate?: (expr: string) => unknown;
+  collectText: typeof collectText;
+  sourceLocation: typeof currentSourceLocation;
+  parseVarArgs: typeof parseVarArgs;
+  extractOptions: typeof extractOptions;
+  wrap: (content: ComponentChildren) => VNode<any>;
+  useAction: (opts: UseActionOptions) => string;
+  h: typeof h;
+  renderNodes: typeof renderNodes;
+  renderInlineNodes: typeof renderInlineNodes;
+  hooks: {
+    useState: typeof useState;
+    useRef: typeof useRef;
+    useEffect: typeof useEffect;
+    useLayoutEffect: typeof useLayoutEffect;
+    useCallback: typeof useCallback;
+    useMemo: typeof useMemo;
+    useContext: typeof useContext;
+  };
+}
+
+export interface MacroDefinition {
+  name: string;
+  subMacros?: string[];
+  interpolate?: boolean;
+  merged?: boolean;
+  storeVar?: boolean;
+  render: (props: MacroProps, ctx: MacroContext) => VNode | null;
+}
+
+const sharedHooks = {
+  useState,
+  useRef,
+  useEffect,
+  useLayoutEffect,
+  useCallback,
+  useMemo,
+  useContext,
+};
+
+export function defineMacro(config: MacroDefinition): void {
+  function Wrapper(props: MacroProps) {
+    // className/id resolved first (interpolate may transform them)
+    let className = props.className;
+    let id = props.id;
+    let resolve: ((s: string | undefined) => string | undefined) | undefined;
+    if (config.interpolate) {
+      resolve = useInterpolate();
+      className = resolve(className);
+      id = resolve(id);
+    }
+
+    // Always-on: cssClass + mutation
+    const { update, getValues } = useContext(LocalsUpdateContext);
+    const ctx: MacroContext = {
+      collectText,
+      sourceLocation: currentSourceLocation,
+      parseVarArgs,
+      extractOptions,
+      h,
+      renderNodes,
+      renderInlineNodes,
+      hooks: sharedHooks,
+      useAction,
+      className,
+      id,
+      resolve,
+      cls: macroClass(config.name, className),
+      mutate: (code: string) => executeMutation(code, getValues(), update),
+      update,
+      getValues,
+      wrap: undefined as any,
+    };
+
+    if (config.merged) {
+      ctx.merged = useMergedLocals();
+      const merged = ctx.merged;
+      ctx.evaluate = (expr: string) =>
+        evaluate(expr, merged[0], merged[1], merged[2]);
+    }
+
+    if (config.storeVar) {
+      const firstToken = props.rawArgs.trim().split(/[\s"']+/)[0] ?? '';
+      const varName = firstToken.replace(/["']/g, '').replace(/^\$/, '');
+      ctx.varName = varName;
+      ctx.value = useStoryStore((s) => s.variables[varName]);
+      const setVariable = useStoryStore((s) => s.setVariable);
+      ctx.setValue = (value: unknown) => setVariable(varName, value);
+    }
+
+    ctx.wrap = (content: ComponentChildren): VNode<any> => {
+      if (ctx.className || ctx.id)
+        return h('span', { id: ctx.id, class: ctx.className }, content);
+      return h(Fragment, null, content);
+    };
+
+    return config.render(props, ctx);
+  }
+
+  registerMacro(config.name, Wrapper);
+  if (config.subMacros) {
+    for (const sub of config.subMacros) registerSubMacro(sub);
+  }
+}

package/src/expression.ts

@@ -6,12 +6,12 @@ import { random, randomInt } from './prng';
 interface ExpressionFns {
   currentPassage: () => Passage | undefined;
   previousPassage: () => Passage | undefined;
-  visited: (name: string) => number;
-  hasVisited: (name: string) => boolean;
+  visited: (name?: string) => number;
+  hasVisited: (name?: string) => boolean;
   hasVisitedAny: (...names: string[]) => boolean;
   hasVisitedAll: (...names: string[]) => boolean;
-  rendered: (name: string) => number;
-  hasRendered: (name: string) => boolean;
+  rendered: (name?: string) => number;
+  hasRendered: (name?: string) => boolean;
   hasRenderedAny: (...names: string[]) => boolean;
   hasRenderedAll: (...names: string[]) => boolean;
   random: () => number;
@@ -191,15 +191,17 @@ export function buildExpressionFns() {
     return cachedFns;
   }
 
-  const visited = (name: string): number => visitCounts[name] ?? 0;
-  const hasVisited = (name: string): boolean => visited(name) > 0;
+  const visited = (name?: string): number =>
+    visitCounts[name ?? useStoryStore.getState().currentPassage] ?? 0;
+  const hasVisited = (name?: string): boolean => visited(name) > 0;
   const hasVisitedAny = (...names: string[]): boolean =>
     names.some((n) => visited(n) > 0);
   const hasVisitedAll = (...names: string[]): boolean =>
     names.every((n) => visited(n) > 0);
 
-  const rendered = (name: string): number => renderCounts[name] ?? 0;
-  const hasRendered = (name: string): boolean => rendered(name) > 0;
+  const rendered = (name?: string): number =>
+    renderCounts[name ?? useStoryStore.getState().currentPassage] ?? 0;
+  const hasRendered = (name?: string): boolean => rendered(name) > 0;
   const hasRenderedAny = (...names: string[]): boolean =>
     names.some((n) => rendered(n) > 0);
   const hasRenderedAll = (...names: string[]): boolean =>

package/src/index.tsx

@@ -5,6 +5,7 @@ import { useStoryStore } from './store';
 import { installStoryAPI } from './story-api';
 import { resetIdCounters } from './action-registry';
 import { executeStoryInit } from './story-init';
+import { loadSession } from './saves/save-manager';
 import {
   parseStoryVariables,
   validatePassages,
@@ -89,6 +90,12 @@ function boot() {
   // Execute StoryInit passage if it exists
   executeStoryInit();
 
+  // Restore session state if the page was refreshed
+  const sessionPayload = loadSession(storyData.ifid);
+  if (sessionPayload) {
+    useStoryStore.getState().loadFromPayload(sessionPayload);
+  }
+
   // Register widgets from passages tagged "widget"
   for (const [, passage] of storyData.passages) {
     if (passage.tags.includes('widget')) {

package/src/macros/register-builtins.ts

@@ -15,13 +15,10 @@ import '../components/macros/Stop';
 import '../components/macros/Type';
 import '../components/macros/Widget';
 import '../components/macros/StoryTitle';
-import '../components/macros/Back';
-import '../components/macros/Forward';
-import '../components/macros/Restart';
-import '../components/macros/QuickSave';
-import '../components/macros/QuickLoad';
-import '../components/macros/SettingsButton';
-import '../components/macros/Saves';
+import '../components/macros/MenubarButtons';
+import '../components/macros/Dialog';
+import '../components/macros/SaveManager';
+import '../components/macros/SettingsControls';
 import '../components/macros/Include';
 import '../components/macros/Goto';
 import '../components/macros/Unset';
@@ -32,4 +29,5 @@ import '../components/macros/Checkbox';
 import '../components/macros/Radiobutton';
 import '../components/macros/Listbox';
 import '../components/macros/Cycle';
+import '../components/macros/Span';
 import '../components/macros/PassageDisplay';

package/src/markup/ast.ts

@@ -5,14 +5,6 @@ export interface TextNode {
   value: string;
 }
 
-export interface LinkNode {
-  type: 'link';
-  display: string;
-  target: string;
-  className?: string;
-  id?: string;
-}
-
 export interface VariableNode {
   type: 'variable';
   name: string;
@@ -45,7 +37,7 @@ export interface HtmlNode {
   children: ASTNode[];
 }
 
-export type ASTNode = TextNode | LinkNode | VariableNode | MacroNode | HtmlNode;
+export type ASTNode = TextNode | VariableNode | MacroNode | HtmlNode;
 
 /** Macros that require a closing tag and can contain children */
 const BLOCK_MACROS = new Set([
@@ -61,6 +53,7 @@ const BLOCK_MACROS = new Set([
   'repeat',
   'type',
   'widget',
+  'span',
 ]);
 
 /** Map from branch macro name → required parent macro name */
@@ -102,14 +95,16 @@ export function buildAST(tokens: Token[]): ASTNode[] {
         break;
 
       case 'link': {
-        const linkNode: LinkNode = {
-          type: 'link',
-          display: token.display,
-          target: token.target,
+        const rawArgs = `"${token.display}" "${token.target}"`;
+        const macroNode: MacroNode = {
+          type: 'macro',
+          name: 'link',
+          rawArgs,
+          children: [],
         };
-        if (token.className) linkNode.className = token.className;
-        if (token.id) linkNode.id = token.id;
-        current().push(linkNode);
+        if (token.className) macroNode.className = token.className;
+        if (token.id) macroNode.id = token.id;
+        current().push(macroNode);
         break;
       }
 

package/src/markup/render.tsx

@@ -1,5 +1,4 @@
 import { createContext } from 'preact';
-import { PassageLink } from '../components/PassageLink';
 import { VarDisplay } from '../components/macros/VarDisplay';
 import { WidgetInvocation } from '../components/macros/WidgetInvocation';
 import { getWidget } from '../widgets/widget-registry';
@@ -136,18 +135,6 @@ function renderSingleNode(
     case 'text':
       return node.value;
 
-    case 'link':
-      return (
-        <PassageLink
-          key={key}
-          target={node.target}
-          className={node.className}
-          id={node.id}
-        >
-          {node.display}
-        </PassageLink>
-      );
-
     case 'variable':
       return (
         <VarDisplay

package/src/saves/save-manager.ts

@@ -299,6 +299,49 @@ export async function loadQuickSave(
   return loadSave(existingId);
 }
 
+// --- Session Persistence (survives F5, cleared on tab close) ---
+
+const SESSION_KEY_PREFIX = 'spindle.session.';
+
+/**
+ * Write a pre-serialized session payload to sessionStorage.
+ * Callers are responsible for serializing variables (see persistSession in store.ts).
+ */
+export function saveSession(ifid: string, data: unknown): void {
+  try {
+    sessionStorage.setItem(
+      `${SESSION_KEY_PREFIX}${ifid}`,
+      JSON.stringify(data),
+    );
+  } catch {
+    // sessionStorage unavailable or full — silently ignore
+  }
+}
+
+export function loadSession(ifid: string): SavePayload | undefined {
+  try {
+    const raw = sessionStorage.getItem(`${SESSION_KEY_PREFIX}${ifid}`);
+    if (!raw) return undefined;
+    const payload: SavePayload = JSON.parse(raw);
+    payload.variables = deserialize(payload.variables);
+    payload.history = payload.history.map((m) => ({
+      ...m,
+      variables: deserialize(m.variables),
+    }));
+    return payload;
+  } catch {
+    return undefined;
+  }
+}
+
+export function clearSession(ifid: string): void {
+  try {
+    sessionStorage.removeItem(`${SESSION_KEY_PREFIX}${ifid}`);
+  } catch {
+    // ignore
+  }
+}
+
 // --- Export / Import ---
 
 export async function exportSave(

package/src/saves/types.ts

@@ -1,10 +1,17 @@
-import type { HistoryMoment } from '../store';
 import type { PRNGSnapshot } from '../prng';
 
+/** History moment as persisted in saves (full variable snapshots). */
+export interface SaveHistoryMoment {
+  passage: string;
+  variables: Record<string, unknown>;
+  timestamp: number;
+  prng?: PRNGSnapshot | null;
+}
+
 export interface SavePayload {
   passage: string;
   variables: Record<string, unknown>;
-  history: HistoryMoment[];
+  history: SaveHistoryMoment[];
   historyIndex: number;
   visitCounts?: Record<string, number>;
   renderCounts?: Record<string, number>;