@rohal12/spindle 0.58.0 → 0.59.0

package/src/tooling.ts

@@ -11,8 +11,11 @@ import {
 } from './markup/validate';
 import { isBlockMacro } from './markup/ast';
 import { tokenizeMarkupTolerant } from './markup/parse';
-import { collectPassageReferences, type PassageReference } from './code-check';
-import { subMacroParameters } from './components/macros/option-utils';
+import {
+  collectPassageReferences,
+  parameterLookup,
+  type PassageReference,
+} from './code-check';
 import { blockWidgetNames } from './widgets/widget-def';
 import type { ParameterDef } from './registry';
 
@@ -71,8 +74,13 @@ export interface ToolingMacro {
   name: string;
   block: boolean;
   subMacros: string[];
-  /** Its declared parameters: their types tell which arguments are code. */
+  /**
+   * Its declared parameters: their types tell which arguments are code, and
+   * what a `string` or `text` argument holds (see ParameterDef.holds).
+   */
   parameters?: readonly ParameterDef[];
+  /** Whether it resolves markup: its strings hold markup by default. */
+  interpolate?: boolean;
 }
 
 /**
@@ -87,20 +95,19 @@ export function validateStoryMarkup(
   options: ValidateMarkupOptions = {},
 ): MarkupDiagnostic[] {
   const list = [...passages];
+  const all = [...macros];
   const known = new Set<string>();
-  const parameters = new Map<string, readonly ParameterDef[] | undefined>();
   const blocks = new Set(blockWidgetNames(list).map((n) => n.toLowerCase()));
-  for (const macro of macros) {
+  for (const macro of all) {
     const name = macro.name.toLowerCase();
     known.add(name);
-    parameters.set(name, macro.parameters);
     for (const sub of macro.subMacros) known.add(sub.toLowerCase());
     if (macro.block) blocks.add(name);
   }
   return validateMarkup(list, {
     isKnownMacro: (name) => known.has(name),
     macroNames: known,
-    parametersOf: (name) => parameters.get(name),
+    parametersOf: parameterLookup(all),
     isBlockMacro: (name) =>
       blocks.has(name.toLowerCase()) || isBlockMacro(name),
     checkPassageNames: options.checkPassageNames,
@@ -116,14 +123,6 @@ export function collectStoryPassageReferences(
   source: string,
   macros: Iterable<ToolingMacro>,
 ): PassageReference[] {
-  const parameters = new Map<string, readonly ParameterDef[] | undefined>();
-  for (const macro of macros) {
-    parameters.set(macro.name.toLowerCase(), macro.parameters);
-  }
   const { tokens } = tokenizeMarkupTolerant(source);
-  return collectPassageReferences(
-    source,
-    tokens,
-    (name) => parameters.get(name.toLowerCase()) ?? subMacroParameters(name),
-  );
+  return collectPassageReferences(source, tokens, parameterLookup(macros));
 }

package/src/widgets/widget-def.ts

@@ -7,8 +7,8 @@ import type { MacroArgs } from '../registry';
 
 /** A {widget} definition's name, then its `@` parameters. */
 export const WIDGET_PARAMETERS = [
-  { name: 'name', type: 'text', required: true },
-  { name: 'parameters', type: 'text' },
+  { name: 'name', type: 'text', holds: 'text', required: true },
+  { name: 'parameters', type: 'text', holds: 'text' },
 ] as const;
 
 export interface WidgetDef {

package/types/index.d.ts

@@ -272,6 +272,27 @@ export type ParameterType =
   | 'separator'
   | 'options';
 
+/**
+ * What the value of a `string` or `text` argument holds, for the check at
+ * story start and for tooling:
+ * - `markup`: markup the macro renders (`{button}`'s label): its markup
+ *   is checked.
+ * - `text`: plain text the macro uses as written (`{checkbox}`'s label).
+ * - `passage`: a passage name (`{watch}`'s `goto`): the passage must exist.
+ * - `expression`, `statements`: code (`{watch}`'s condition and `run`): it
+ *   is checked as code, and its variable references against the schema.
+ *
+ * Without it, the argument of a macro with `interpolate` holds `markup`,
+ * any other `text`.
+ * @see {@link ../../src/registry.ts} for the implementation.
+ */
+export type StringHolds =
+  | 'markup'
+  | 'text'
+  | 'passage'
+  | 'expression'
+  | 'statements';
+
 /**
  * Parameter metadata for a macro definition.
  * @see {@link ../../src/registry.ts} for the implementation.
@@ -282,6 +303,8 @@ export interface ParameterDef {
   description?: string;
   /** How the argument is read: required, there is no default. */
   type: ParameterType;
+  /** What a `string` or `text` argument holds (see StringHolds). */
+  holds?: StringHolds;
   /** The options of an `options` parameter. */
   parameters?: readonly ParameterDef[];
 }

package/types/tooling.d.ts

@@ -30,12 +30,34 @@ export type ParameterType =
   | 'separator'
   | 'options';
 
+/**
+ * What the value of a `string` or `text` argument holds, for the check at
+ * story start and for tooling:
+ * - `markup`: markup the macro renders (`{button}`'s label): its markup
+ *   is checked.
+ * - `text`: plain text the macro uses as written (`{checkbox}`'s label).
+ * - `passage`: a passage name (`{watch}`'s `goto`): the passage must exist.
+ * - `expression`, `statements`: code (`{watch}`'s condition and `run`): it
+ *   is checked as code, and its variable references against the schema.
+ *
+ * Without it, the argument of a macro with `interpolate` holds `markup`,
+ * any other `text`.
+ */
+export type StringHolds =
+  | 'markup'
+  | 'text'
+  | 'passage'
+  | 'expression'
+  | 'statements';
+
 export interface ParameterDef {
   name: string;
   required?: boolean;
   description?: string;
   /** How the argument is read: required, there is no default. */
   type: ParameterType;
+  /** What a `string` or `text` argument holds (see StringHolds). */
+  holds?: StringHolds;
   /** The options of an `options` parameter. */
   parameters?: readonly ParameterDef[];
 }
@@ -285,6 +307,9 @@ export interface LinkToken extends TokenSpan, Selectors {
   type: 'link';
   display: string;
   target: string;
+  /** Where the target is written, from `targetStart` to `targetEnd`. */
+  targetStart: number;
+  targetEnd: number;
 }
 
 export interface MacroToken extends TokenSpan, Selectors {
@@ -465,8 +490,9 @@ export interface PassageReference {
  * The passages the markup of `source` names, in source order: `[[…]]` links,
  * the passage of `{goto}`, `{include}` and `{link}` (and of macros that
  * declare a `passage` argument), the `goto` and `dialog` actions of
- * `{watch}` and the body of `{dialog}`. Malformed tags are skipped, so
- * half-typed markup reads.
+ * `{watch}` (and the `string` and `text` arguments of macros that declare
+ * they hold a passage name) and the body of `{dialog}`. Malformed tags are
+ * skipped, so half-typed markup reads.
  */
 export declare function collectPassageReferences(
   source: string,