ferrovue 0.2.0 → 0.4.0

package/dist/emitter.d.ts

@@ -1,23 +1,15 @@
-/** Statements, with adjacent literal pushes merged into one `push_str`. */
 export declare class Emitter {
     lines: string[];
-    /** Bytes of markup written once per render, part of what `render` reserves up front: the literal
-     * markup, and what the numbers written at run time are expected to take. */
     literalBytes: number;
-    /** Rust expressions for the rest of the reservation: a loop's markup once per item. */
     perItem: string[];
     private pending;
     private depth;
     lit(s: string): void;
-    /** `bytes` more expected of a value written at run time. */
     expect(bytes: number): void;
     stmt(code: string): void;
     open(code: string): void;
     close(tail?: string): void;
-    /** Whether the lines from \`from\` on read \`name\`. Literals are skipped, so markup that happens to
-     * spell the name does not count, and so are fields of that name. */
     reads(name: string, from: number): boolean;
-    /** Replace \`from\` with \`to\` in line \`index\`: an unused binding renamed to \`_\`. */
     replace(index: number, from: string, to: string): void;
     flush(): void;
 }

package/dist/emitter.js

@@ -1,13 +1,8 @@
-/* The Rust statements a render is written as. */
 import { rustChar, rustStr } from "./model.js";
 import { occurrences } from "./parens.js";
-/** Statements, with adjacent literal pushes merged into one `push_str`. */
 export class Emitter {
     lines = [];
-    /** Bytes of markup written once per render, part of what `render` reserves up front: the literal
-     * markup, and what the numbers written at run time are expected to take. */
     literalBytes = 0;
-    /** Rust expressions for the rest of the reservation: a loop's markup once per item. */
     perItem = [];
     pending = "";
     depth = 1;
@@ -15,7 +10,6 @@ export class Emitter {
         this.pending += s;
         this.literalBytes += Buffer.byteLength(s);
     }
-    /** `bytes` more expected of a value written at run time. */
     expect(bytes) {
         this.literalBytes += bytes;
     }
@@ -31,19 +25,14 @@ export class Emitter {
         this.flush();
         this.depth--;
         this.lines.push("    ".repeat(this.depth) + "}" + tail);
-        // `} else {` closes one block and opens the next.
         if (tail.endsWith("{"))
             this.depth++;
     }
-    /** Whether the lines from \`from\` on read \`name\`. Literals are skipped, so markup that happens to
-     * spell the name does not count, and so are fields of that name. */
     reads(name, from) {
         this.flush();
         return occurrences(this.lines.slice(from).join("\n"), name) > 0;
     }
-    /** Replace \`from\` with \`to\` in line \`index\`: an unused binding renamed to \`_\`. */
     replace(index, from, to) {
-        // A function, so a `$&` or `$'` in the generated text is not read as a replacement pattern.
         this.lines[index] = this.lines[index].replace(from, () => to);
     }
     flush() {
@@ -51,7 +40,6 @@ export class Emitter {
             return;
         const text = this.pending;
         this.pending = "";
-        // One character is pushed as a `char`.
         const push = /^.$/su.test(text) ? `out.push(${rustChar(text)});` : `out.push_str(${rustStr(text)});`;
         this.lines.push("    ".repeat(this.depth) + push);
     }

package/dist/expr.d.ts

@@ -1,76 +1,6 @@
 import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
-/** The refusal for a string that may hold half of a surrogate pair, used where that half matters. */
-export declare function lonely(what: string): string;
-/** Two strings meeting, where a half of a surrogate pair — which ferrovue holds as U+FFFD — would
- * change the result:
- * - `equal`: two halves may differ, and a half never equals a literal U+FFFD;
- * - `order`: a half orders as a surrogate, below U+E000, where U+FFFD orders above — the same only
- *   against a literal of characters below U+D800, which both order after;
- * - `search`: a half searched for (`b`) matches half of a whole pair in `a`;
- * - `join`: two halves side by side join into one character.
- * A string holding U+FFFD in the data still equals, or is found in, a half: README, "Strings". */
-export declare function meet(comp: Component, a: Val, b: Val, what: string, n: N, how: "equal" | "order" | "search" | "join"): void;
-/** Whether a string expression borrows from a temporary it builds — \`&*format!(…)\`, a call that
- * returns a \`String\` — rather than from the props or the state. Such a borrow ends with the block
- * it is in, so a branch of \`?:\` or \`||\` must hand back the string itself. */
-export declare function isTemporary(v: Val): boolean;
-/** A string as a \`Cow\`: borrowed when it lives on, owned when it is a temporary. The \`Cow\` is
- * itself a temporary of the whole statement, so the \`&str\` taken from it lives to its end. A
- * \`String\` built for the purpose is moved into it, and one that is already a \`Cow\` — a branch
- * of \`?:\` or \`||\` — is taken as it is. */
-export declare function asCow(v: Val): string;
-/** Whether built code is a `Cow<str>` already: a runtime routine that borrows when it can
- * (`js_slice`, `js_replace`, `js_pad_start`, …), or a fallback taken from one (`.unwrap_or(Cow…)`). */
-export declare function yieldsCow(code: string): boolean;
-/** Whether a value is a JavaScript number: an integer or a fraction. */
-export declare function isNumber(ty: Ty): boolean;
-/** A number as an `f64`, as JavaScript holds every number. */
-export declare function asF64(v: Val): string;
-/** A type as an error names it. */
 export declare function describeTy(ty: Ty): string;
 export declare function fieldVal(comp: Component, base: string, ty: Ty, js: string, node: N): Val;
-/** A value's truthiness when it is known at generation time: a boolean constant, a string literal,
- * a number JavaScript computed. */
-export declare function known(v: Val): boolean | undefined;
-export declare function truthy(v: Val): string;
-/** A value passed where `want` is expected: a present value into an optional slot is wrapped. */
 export declare function coerce(comp: Component, v: Val, want: Ty, node: N): string;
-/** The JavaScript path an expression names — `$props.user`, `item.author.name` — or `null` when it
- * is not a plain chain of names. */
-export declare function pathOf(n: N): string | null;
-/** A test that an optional value is present, as TypeScript narrows on it: `x`, `x !== undefined`,
- * and, `negated`, `!x` and `x === undefined`, after which the value is present in the other branch. */
-export interface Presence {
-    path: string;
-    /** The value bound where it is present, and its type there. */
-    pattern: (name: string) => string;
-    /** The `Option` the pattern matches: the value, or for a truthiness test only its truthy values. */
-    option: string;
-    /** The test alone, for a branch that never reads the value. */
-    present: string;
-    of: Ty;
-    negated: boolean;
-    /** Tested by truthiness, so the test itself is a boolean only when it is negated. */
-    truthy: boolean;
-}
-export declare function presence(s: Scope, n: N): Presence | null;
-/** The scope with `p`'s value present, bound as `name`. */
-export declare function narrowTo(s: Scope, p: Presence, name: string): Scope;
-export declare function cond(s: Scope, n: N): string;
 export declare function childOf(name: string): Component;
-/** The reader's route, which the component then takes. */
-export declare function theRoute(s: Scope, n: N): Val;
-/** A field of the route: what `useRoute()` gives that the server knows as vue-router does. */
-export declare function routeField(s: Scope, base: Val, prop: string, n: N): Val;
-/** A Pinia getter read from a store's state, `prefs.doubled`: its expression, translated with the
- * state it takes bound to that state. `null` when `name` is not a getter of that store. */
-export declare function storeGetter(s: Scope, base: Val, name: string, node: N): Val | null;
-/** A Rust string literal's text. */
-export declare function unquote(literal: string): string;
 export declare function expr(s: Scope, n: N): Val;
-/** A boolean computed at run time, or known now when it folded to a constant. */
-export declare function boolOf(code: string): Val;
-export declare function call(s: Scope, n: N): Val;
-/** Whether `n` is `Object.<method>(…)`. */
-export declare function isObjectCall(n: N, method: string): boolean;
-export declare function helperCall(s: Scope, name: string, args: N[], n: N): Val;