fewrd 0.3.0 → 1.0.1

package/dist/types/playground.d.ts

@@ -1,34 +1,32 @@
-import { type Fold } from './index.ts';
-import type { Book, Resolver } from './types.ts';
+import { type Resolve } from './index.ts';
 export interface PlaygroundCase {
     name: string;
+    /** The key of the conf in `confs` this case is found with. */
+    conf: string;
     text: string;
+    /** The tags folded when the case is first shown, and the gist that fold should give. */
+    fold?: string[];
+    gist?: string;
 }
-interface CommonOptions {
-    cases: PlaygroundCase[];
-    /** Evaluated once at mount, against `cases`, to seed the fold control's initial selection. Never called again. */
-    fold?: Fold;
+export interface PlaygroundConf {
+    conf: unknown;
+    resolvers?: Readonly<Record<string, Resolve>>;
 }
-export type MountOptions = (CommonOptions & {
-    book: Book;
-})
-/** Book data (e.g. parsed JSON) and its resolvers: the playground shows an editor and recompiles on every edit. */
- | (CommonOptions & {
-    data: unknown;
-    resolvers?: Readonly<Record<string, Resolver>>;
-    /** Shows a save button: called with the editor's text once it parses as JSON. Reset then returns to what was saved. */
-    save?: (json: string) => unknown;
-});
-/** Distinct entities across a book's recipes, in first-appearance order. */
-export declare function entities(book: Book): string[];
-/** Which entities a supplied fold would fold across the given cases, or none if no fold was supplied. */
-export declare function initialSelection(book: Book, cases: PlaygroundCase[], fold?: Fold): string[];
 /**
- * Mount fewrd's playground UI into `el`, rendering `options.cases` against
- * `options.book` — or against `options.data` compiled with
- * `options.resolvers`, editable live. Self-contained: injects the CSS it
- * needs, scoped to this mount so multiple mounts on one page never collide
- * and unrelated page content is never touched.
+ * Mount the playground on `el`: `confs` are named confs (data, typically JSON
+ * imports) with their resolvers, and every case says which one it uses. One case
+ * shows at a time, stepped with the buttons, the jump menu or the arrow keys; the
+ * editor shows the conf of the current case and recompiles it on every edit, so
+ * only that domain's cases change. Injects its own scoped styles; light and dark
+ * follow the OS unless the theme switch says otherwise.
+ *
+ * ponytail: the case is found again on every keystroke; debounce if a conf or a
+ * case ever makes typing lag. A character outside the BMP takes two string
+ * positions but one glyph, so bands after it drift by one `ch`; measure with
+ * Range rects if real subjects need it. A newline in a text is not handled. The
+ * tree is not keyboard-navigable: the bands are, and they light their tree rows.
  */
-export declare function mount(el: Element, options: MountOptions): void;
-export {};
+export declare function mount(el: HTMLElement, options: {
+    confs: Readonly<Record<string, PlaygroundConf>>;
+    cases: readonly PlaygroundCase[];
+}): void;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "fewrd",
-  "version": "0.3.0",
+  "version": "1.0.1",
   "type": "module",
   "license": "MIT",
-  "description": "Finds what recurs in a string, cuts it loose, and gets you the gist in a few words.",
+  "description": "Finds what recurs in a string, and lets a reader fold it away.",
   "keywords": [
     "text",
     "segmentation",
@@ -20,8 +20,7 @@
   "homepage": "https://github.com/egildo/fewrd#readme",
   "bugs": "https://github.com/egildo/fewrd/issues",
   "files": [
-    "dist",
-    "book.schema.json"
+    "dist"
   ],
   "exports": {
     ".": {
@@ -31,12 +30,12 @@
     "./playground": {
       "types": "./dist/types/playground.d.ts",
       "default": "./dist/playground.js"
-    },
-    "./book.schema.json": "./book.schema.json"
+    }
   },
   "scripts": {
     "test": "node --test \"test/*.test.ts\"",
     "typecheck": "tsc",
+    "bench": "node bench.ts",
     "build": "vite build --config vite.lib.ts && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build",
     "dev": "vite playground --port 5577 --strictPort"

package/book.schema.json

@@ -1,62 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "title": "fewrd book",
-  "description": "A fewrd recipe book written as data. Compile it with compile(data, { resolvers }) from 'fewrd'.",
-  "type": "object",
-  "properties": {
-    "$schema": {
-      "type": "string",
-      "description": "Where this schema is, e.g. ./node_modules/fewrd/book.schema.json. Ignored by compile."
-    },
-    "version": {
-      "type": "string",
-      "minLength": 1,
-      "description": "Keys a cached reading. Change it whenever a change to the recipes can change output."
-    },
-    "defs": {
-      "type": "object",
-      "description": "Named pattern fragments: source only, no slashes, no flags. Reference one from any pattern or fragment as %{NAME}; it splices in as one unit.",
-      "propertyNames": { "pattern": "^[A-Za-z_][A-Za-z0-9_]*$" },
-      "additionalProperties": { "type": "string" }
-    },
-    "recipes": {
-      "type": "array",
-      "description": "Recipes in priority order.",
-      "items": { "$ref": "#/$defs/recipe" }
-    }
-  },
-  "required": ["version", "recipes"],
-  "additionalProperties": false,
-  "$defs": {
-    "pattern": {
-      "type": "string",
-      "pattern": "^/.*/[dgimsuvy]*$",
-      "description": "A regex as /source/flags, e.g. \"/C\\\\.?U\\\\.?P/iu\". %{NAME} splices in a fragment from defs."
-    },
-    "neighbour": {
-      "type": "object",
-      "properties": {
-        "part": { "type": "string", "minLength": 1, "description": "The part name this neighbour attaches as, e.g. label, date, unit." },
-        "rx": { "$ref": "#/$defs/pattern", "description": "Written plainly: the engine pins it to the anchor's edge." }
-      },
-      "required": ["part", "rx"],
-      "additionalProperties": false
-    },
-    "recipe": {
-      "type": "object",
-      "properties": {
-        "entity": { "type": "string", "minLength": 1, "description": "What this recipe recognises; mentions carry it." },
-        "anchor": { "$ref": "#/$defs/pattern", "description": "The value, strict. Its part is value (lead on a rest recipe)." },
-        "left": { "type": "array", "items": { "$ref": "#/$defs/neighbour" }, "description": "Neighbours tried leftward from the anchor, in priority order." },
-        "right": { "type": "array", "items": { "$ref": "#/$defs/neighbour" }, "description": "Neighbours tried rightward from the anchor, in priority order." },
-        "requires": { "type": "array", "items": { "type": "string" }, "description": "Parts that must attach, or the candidate is dropped." },
-        "resolve": { "type": "string", "minLength": 1, "description": "Name of a resolver passed to compile: canonical value from the parts, or null (not this entity after all)." },
-        "weak": { "type": "boolean", "description": "Fills only the gaps the strong recipes leave." },
-        "rest": { "type": "boolean", "description": "The mention runs from its anchor to the end of its level, and what follows is read again inside it. Neighbours are ignored." },
-        "glued": { "type": "boolean", "description": "The anchor may start or end inside a word." }
-      },
-      "required": ["entity", "anchor"],
-      "additionalProperties": false
-    }
-  }
-}

package/dist/types/compile.d.ts

@@ -1,26 +0,0 @@
-import type { Book, CompileError, CompileOptions } from './types.ts';
-/** The keys each object accepts and requires. `book.schema.json` must agree (tested). */
-export declare const KEYS: {
-    book: {
-        all: string[];
-        required: string[];
-    };
-    recipe: {
-        all: string[];
-        required: string[];
-    };
-    neighbour: {
-        all: string[];
-        required: string[];
-    };
-};
-/**
- * Compile a book written as data (typically `JSON.parse` output) into a Book.
- * `resolve` names are looked up in `options.resolvers`; nothing in `data` is
- * ever evaluated as code. A recipe with any error is left out; the others
- * keep their order.
- */
-export declare function compile(data: unknown, options?: CompileOptions): {
-    book: Book;
-    errors: CompileError[];
-};

package/dist/types/read.d.ts

@@ -1,3 +0,0 @@
-import type { Book, Cuts } from './types.ts';
-/** Read `text` with `book`: every mention, and the partition of the text into leaves. */
-export declare function read(text: string, book: Book): Cuts;

package/dist/types/render.d.ts

@@ -1,21 +0,0 @@
-import type { Cuts, Mention } from './types.ts';
-export type Fold = (mention: Mention, index: number) => boolean;
-/**
- * Which leaves the condensed view shows. With nothing folded, every leaf.
- *
- * - A mention folds when the policy says so, or when the mention holding it folds.
- * - A bracket pair folds when nothing between them survives.
- * - The separators between two surviving leaves survive untouched when no
- *   fold fell among them; otherwise only the strongest one survives, and none
- *   at an edge, after an opening bracket or before closing punctuation.
- */
-export declare function shown(cuts: Cuts, fold: Fold): boolean[];
-/** The condensed view as plain text. */
-export declare function gist(cuts: Cuts, fold: Fold): string;
-/**
- * Tagged HTML holding both views: every leaf is there, and what the condensed
- * view drops carries `data-fold` — so `.condensed [data-fold] { display: none }`
- * is the whole switch. Mentions are `<span data-entity data-mention>`, parts
- * `<span data-part>`, separators `<span data-sep>`, nested as the mentions nest.
- */
-export declare function html(cuts: Cuts, fold: Fold): string;

package/dist/types/types.d.ts

@@ -1,123 +0,0 @@
-/** Half-open, indices into the ORIGINAL string. */
-export interface Span {
-    start: number;
-    end: number;
-}
-/**
- * A neighbour a recipe may attach beside its anchor. Write `rx` plainly: the
- * engine pins it to the anchor's edge (`$` on the left, sticky on the right).
- */
-export interface Neighbour {
-    part: string;
-    rx: RegExp;
-}
-/**
- * One pattern: a strict anchor, then a closed list of neighbours tried outward.
- * Each neighbour attaches at most once; after every attachment the list is
- * tried again from the top, so declaration order is priority at each step.
- */
-export interface Recipe {
-    entity: string;
-    /** The value, strict. Its part is `value` (`lead` on a `rest` recipe). */
-    anchor: RegExp;
-    left?: readonly Neighbour[];
-    right?: readonly Neighbour[];
-    /** Parts that must attach, or the candidate is dropped. */
-    requires?: readonly string[];
-    /** Canonical value from the attached parts' text, or null: not this entity after all. */
-    resolve?: (parts: Readonly<Record<string, string>>) => string | null;
-    /** Fills only the gaps the strong recipes leave. */
-    weak?: boolean;
-    /**
-     * The mention runs from its anchor to the end of its level, and what follows
-     * the anchor is read again inside it. Neighbours are ignored.
-     */
-    rest?: boolean;
-    /** The anchor may start or end inside a word. Default: it may not. */
-    glued?: boolean;
-}
-/** Recipes in priority order, and the version that keys a cached reading. */
-export interface Book {
-    version: string;
-    recipes: readonly Recipe[];
-}
-/** A recipe's `resolve`, supplied by name at compile time. */
-export type Resolver = NonNullable<Recipe['resolve']>;
-/** A `Neighbour` as data. `rx` is a pattern: `"/source/flags"`. */
-export interface NeighbourData {
-    part: string;
-    rx: string;
-}
-/**
- * A `Recipe` as data. Patterns are `"/source/flags"` strings, where
- * `%{NAME}` splices in `BookData.defs.NAME` as one unit; `resolve` names a
- * function from `CompileOptions.resolvers`.
- */
-export interface RecipeData {
-    entity: string;
-    anchor: string;
-    left?: NeighbourData[];
-    right?: NeighbourData[];
-    requires?: string[];
-    resolve?: string;
-    weak?: boolean;
-    rest?: boolean;
-    glued?: boolean;
-}
-/** A `Book` as data: the JSON a book is written in. */
-export interface BookData {
-    $schema?: string;
-    version: string;
-    /** Name → pattern source (no slashes, no flags), referenced as `%{NAME}`. */
-    defs?: Record<string, string>;
-    recipes: RecipeData[];
-}
-/** One problem found by `compile`. `recipe` indexes `BookData.recipes`. */
-export interface CompileError {
-    /** Where in the data, e.g. `recipes[2].left[0].rx`; `""` is the root. */
-    path: string;
-    recipe?: number;
-    entity?: string;
-    message: string;
-}
-export interface CompileOptions {
-    resolvers?: Readonly<Record<string, Resolver>>;
-}
-export interface Mention {
-    entity: string;
-    /** Index into the book's recipes. */
-    recipe: number;
-    /** Every part, contiguous: what folding removes. */
-    extent: Span;
-    /** In text order. */
-    parts: {
-        part: string;
-        span: Span;
-    }[];
-    /** `resolve`'s answer, or the anchor's text. */
-    value: string;
-    /** The `rest` mention this one sits inside. */
-    parent?: number;
-}
-export type LeafKind = 'text' | 'sep' | 'open' | 'close' | 'part';
-/**
- * One piece of the partition. `mention` is the innermost mention holding it
- * (a `text` or `sep` leaf may sit inside a `rest` mention).
- */
-export interface Leaf {
-    start: number;
-    end: number;
-    kind: LeafKind;
-    part?: string;
-    mention?: number;
-}
-/**
- * The cuts index: leaves partition `text` in order, no gap, no overlap —
- * concatenating their slices gives `text` back, character for character.
- */
-export interface Cuts {
-    text: string;
-    book: string;
-    mentions: Mention[];
-    leaves: Leaf[];
-}