@typed/template 0.14.0 → 1.0.0-beta.0

package/dist/Parser.js

@@ -0,0 +1,437 @@
+/* eslint-disable no-restricted-syntax */
+import { tokenize } from "html5parser";
+import { keyToPartType } from "./internal/keyToPartType.js";
+import { PART_STRING } from "./internal/meta.js";
+import { PathStack } from "./internal/PathStack.js";
+import { templateHash } from "./internal/templateHash.js";
+import * as Template from "./Template.js";
+let parser;
+/**
+ * Parses a template string array (from a tagged template literal) into a reusable `Template` object.
+ *
+ * This parser handles:
+ * - Standard HTML structure (elements, attributes, text, comments).
+ * - Custom part syntax for interpolation (e.g., `${value}`).
+ * - Special attributes like `.property`, `@event`, `?boolean`.
+ * - Self-closing tags and text-only elements (script, style).
+ *
+ * The result is a cached `Template` instance that contains the static AST and dynamic part locations.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@typed/template/Parser"
+ * import * as Template from "@typed/template/Template"
+ *
+ * // Parse a template
+ * const template = parse`<div id=${"my-id"} class="container">
+ *   <p>Hello, ${"world"}!</p>
+ * </div>`
+ *
+ * // Access parsed structure
+ * console.log(template.nodes) // Array of parsed nodes
+ * console.log(template.parts) // Array of dynamic interpolation points
+ * console.log(template.hash) // Unique hash for the template
+ * ```
+ *
+ * @param template - The template strings array from a tagged template literal.
+ * @returns A `Template` object representing the parsed structure.
+ * @since 1.0.0
+ * @category parsing
+ */
+export function parse(template) {
+    parser ??= new Parser();
+    return parser.parse(template);
+}
+class Parser {
+    html;
+    tokens;
+    index;
+    parts;
+    path;
+    parse(templateStrings) {
+        this.init(templateStrings);
+        return new Template.Template(this.parseNodes(), templateHash(templateStrings), this.parts);
+    }
+    init(templateStrings) {
+        this.html = templateWithParts(templateStrings);
+        this.tokens = tokenize(this.html);
+        this.index = 0;
+        this.parts = [];
+        this.path = new PathStack();
+    }
+    peek() {
+        return this.tokens[this.index];
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+    consumeNextTokenOfKind(kind) {
+        const token = this.tokens[this.index];
+        if (token.type !== kind) {
+            throw new Error(`Expected ${TokenKindToName[kind]} but got ${TokenKindToName[token.type]}`);
+        }
+        this.index++;
+        return token;
+    }
+    consumeWhitespace() {
+        while (this.tokens[this.index]?.type === TokenKind.Whitespace) {
+            this.index++;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+    consumeNextTokenOfKinds(...kinds) {
+        const token = this.tokens[this.index];
+        if (!kinds.includes(token.type)) {
+            throw new Error(`Expected ${kinds.map((kind) => TokenKindToName[kind]).join(" or ")} but got ${TokenKindToName[token.type]}`);
+        }
+        this.index++;
+        return token;
+    }
+    parseNodes() {
+        const nodes = [];
+        while (this.index < this.tokens.length) {
+            const token = this.consumeNextTokenOfKinds(TokenKind.Literal, TokenKind.OpenTag, TokenKind.CloseTag, TokenKind.Whitespace);
+            if (token.type === TokenKind.Literal) {
+                nodes.push(...this.parseNodeParts(token));
+            }
+            else if (token.type === TokenKind.OpenTag) {
+                nodes.push(this.parseOpenTag(token));
+                this.path.inc();
+            }
+            else if (token.type === TokenKind.CloseTag) {
+                this.consumeWhitespace();
+                break;
+            }
+            else if (nodes.length > 0) {
+                nodes.push(new Template.TextNode(token.value));
+                this.path.inc();
+            }
+        }
+        return nodes;
+    }
+    parseNodeParts(literal) {
+        return parseTextAndParts(literal.value, (index) => this.addPartWithPrevious(new Template.NodePart(index)), () => this.path.inc());
+    }
+    parseOpenTag({ value }) {
+        if (value === "!--")
+            return this.parseCommentNode();
+        if (value === "!doctype")
+            return this.parseDocTypeNode();
+        if (SELF_CLOSING_TAGS.has(value))
+            return this.parseSelfClosingElementNode(value);
+        if (TEXT_ONLY_NODES_REGEX.has(value))
+            return this.parseTextOnlyElementNode(value);
+        // All other elements
+        const { attributes, wasSelfClosed } = this.parseAttributes();
+        const children = wasSelfClosed ? [] : this.parseChildren();
+        return new Template.ElementNode(value, attributes, children);
+    }
+    parseChildren() {
+        this.path.push();
+        const children = this.parseNodes();
+        this.path.pop();
+        return children;
+    }
+    parseCommentNode() {
+        const { value } = this.consumeNextTokenOfKind(TokenKind.Literal);
+        this.consumeNextTokenOfKind(TokenKind.OpenTagEnd);
+        return this.parseMultipleParts(value, (index) => new Template.CommentPartNode(index), (text) => new Template.CommentNode(text.value), (parts) => new Template.SparseCommentNode(parts));
+    }
+    parseDocTypeNode() {
+        this.consumeWhitespace();
+        // Try to parse the name
+        const parsedName = this.parseLiteralLike();
+        if (parsedName.closed)
+            return new Template.DocType("html");
+        const name = parsedName.value ?? "html";
+        const { closed, publicId, systemId } = this.parseDocTypeIds();
+        if (!closed) {
+            this.consumeWhitespace();
+            this.consumeNextTokenOfKind(TokenKind.OpenTagEnd);
+        }
+        return new Template.DocType(name, publicId, systemId);
+    }
+    parseDocTypeIds() {
+        const firstIdType = this.parseDocTypeId();
+        if (firstIdType.closed)
+            return firstIdType;
+        const secondIdType = this.parseDocTypeId();
+        return {
+            closed: secondIdType.closed,
+            publicId: secondIdType.publicId ?? firstIdType.publicId,
+            systemId: secondIdType.systemId ?? firstIdType.systemId,
+        };
+    }
+    parseDocTypeId() {
+        const parsedIdType = this.parseLiteralLike();
+        if (parsedIdType.closed || parsedIdType.value === null) {
+            return { closed: parsedIdType.closed, publicId: undefined, systemId: undefined };
+        }
+        const value = parsedIdType.value.toLowerCase();
+        if (value === "public" || value === "system") {
+            const parsedLiteral = this.parseLiteralLike();
+            if (parsedLiteral.closed || parsedLiteral.value === null) {
+                return { closed: parsedLiteral.closed, publicId: undefined, systemId: undefined };
+            }
+            return {
+                closed: false,
+                publicId: value === "public" ? parsedLiteral.value : undefined,
+                systemId: value === "system" ? parsedLiteral.value : undefined,
+            };
+        }
+        return { closed: false, publicId: undefined, systemId: undefined };
+    }
+    parseLiteralLike() {
+        this.consumeWhitespace();
+        const { type, value } = this.consumeNextTokenOfKinds(TokenKind.Literal, TokenKind.AttrValueNq, TokenKind.AttrValueDq, TokenKind.AttrValueSq, TokenKind.OpenTagEnd);
+        if (type === TokenKind.OpenTagEnd)
+            return { closed: true, value: null };
+        if (type === TokenKind.Literal || type === TokenKind.AttrValueNq)
+            return { closed: false, value };
+        if (type === TokenKind.AttrValueDq || type === TokenKind.AttrValueSq) {
+            return { closed: false, value: value.slice(1, -1) };
+        }
+        throw new Error(`Unexpected token ${TokenKindToName[type]} in place of literal`);
+    }
+    parseSelfClosingElementNode(name) {
+        const { attributes } = this.parseAttributes();
+        return new Template.SelfClosingElementNode(name, attributes);
+    }
+    parseTextOnlyElementNode(name) {
+        const { attributes, wasSelfClosed } = this.parseAttributes();
+        const textContent = wasSelfClosed ? null : this.parseTextOnlyChildren();
+        return new Template.TextOnlyElement(name, attributes, textContent);
+    }
+    parseAttributes() {
+        let wasSelfClosed = false;
+        const attributes = [];
+        this.consumeWhitespace();
+        while (this.index < this.tokens.length) {
+            const token = this.peek();
+            if (token.type === TokenKind.OpenTagEnd) {
+                this.index++;
+                wasSelfClosed = token.value === "/";
+                this.consumeWhitespace();
+                break;
+            }
+            if (token.type === TokenKind.Whitespace) {
+                this.index++;
+                continue;
+            }
+            const { attribute, isSelfClosed, shouldContinue } = this.parseAttribute();
+            attributes.push(attribute);
+            wasSelfClosed ||= isSelfClosed;
+            if (!shouldContinue) {
+                this.consumeWhitespace();
+                break;
+            }
+        }
+        return {
+            attributes,
+            wasSelfClosed,
+        };
+    }
+    parseAttribute() {
+        const { value: name } = this.consumeNextTokenOfKind(TokenKind.AttrValueNq);
+        if (isSpreadAttribute(name)) {
+            return {
+                shouldContinue: true,
+                isSelfClosed: false,
+                attribute: this.parsePropertiesAttribute(name.slice(3)),
+            };
+        }
+        const next = this.consumeNextTokenOfKinds(TokenKind.AttrValueEq, TokenKind.Whitespace, TokenKind.OpenTagEnd);
+        if (next.type === TokenKind.AttrValueEq) {
+            const { type, value } = this.consumeNextTokenOfKinds(TokenKind.AttrValueDq, TokenKind.AttrValueSq, TokenKind.AttrValueNq);
+            return {
+                shouldContinue: true,
+                isSelfClosed: false,
+                attribute: this.parseAttributeWithValue(name, type === TokenKind.AttrValueNq ? value : value.slice(1, -1)),
+            };
+        }
+        else if (next.type === TokenKind.Whitespace) {
+            return {
+                shouldContinue: true,
+                isSelfClosed: false,
+                attribute: new Template.BooleanNode(name),
+            };
+        }
+        else if (next.type === TokenKind.OpenTagEnd) {
+            this.consumeWhitespace();
+            return {
+                shouldContinue: false,
+                isSelfClosed: next.value === "/",
+                attribute: new Template.BooleanNode(name),
+            };
+        }
+        else {
+            throw new Error(`Unexpected token ${TokenKindToName[next.type]} in place of attribute`);
+        }
+    }
+    parseAttributeWithValue(rawName, value) {
+        const [match, name] = keyToPartType(rawName);
+        switch (match) {
+            case "attr":
+                return this.parseAttributePart(value, name);
+            case "boolean":
+                return this.parseBooleanAttribute(value, name);
+            case "class":
+                return this.parseClassNameAttribute(value);
+            case "data":
+                return this.parseDataAttribute(value);
+            case "event":
+                return this.parseEventAttribute(value, name);
+            case "properties":
+                return this.parsePropertiesAttribute(value);
+            case "property":
+                return this.parsePropertyAttribute(value, name);
+            case "ref":
+                return this.parseRefAttribute(value);
+        }
+    }
+    parseAttributePart(value, name) {
+        return this.parseMultipleParts(value, (index) => new Template.AttrPartNode(name, index), (text) => new Template.AttributeNode(name, text.value), (parts) => new Template.SparseAttrNode(name, parts));
+    }
+    parseBooleanAttribute(value, name) {
+        return this.parseMultipleParts(value, (index) => new Template.BooleanPartNode(name, index), () => new Template.BooleanNode(name), () => {
+            throw new Error("Boolean attributes cannot have multiple parts");
+        });
+    }
+    parseClassNameAttribute(value) {
+        return this.parseMultipleParts(value, (index) => new Template.ClassNamePartNode(index), (text) => new Template.AttributeNode("class", text.value.trim()), (parts) => new Template.SparseClassNameNode(parts));
+    }
+    parseDataAttribute(value) {
+        return this.addPart(new Template.DataPartNode(unsafeParsePartIndex(value)));
+    }
+    parseEventAttribute(value, name) {
+        return this.addPart(new Template.EventPartNode(name, unsafeParsePartIndex(value)));
+    }
+    parsePropertyAttribute(value, name) {
+        return this.addPart(new Template.PropertyPartNode(name, unsafeParsePartIndex(value)));
+    }
+    parsePropertiesAttribute(value) {
+        return this.addPart(new Template.PropertiesPartNode(unsafeParsePartIndex(value)));
+    }
+    parseRefAttribute(value) {
+        return this.addPart(new Template.RefPartNode(unsafeParsePartIndex(value)));
+    }
+    parseTextOnlyChildren() {
+        const { type, value } = this.consumeNextTokenOfKinds(TokenKind.Literal, TokenKind.CloseTag);
+        if (type === TokenKind.Literal) {
+            this.consumeNextTokenOfKind(TokenKind.CloseTag);
+            return this.parseMultipleParts(value, (index) => new Template.TextPartNode(index), (text) => text, (parts) => new Template.SparseTextNode(parts));
+        }
+        this.consumeWhitespace();
+        return null;
+    }
+    parseMultipleParts(value, createPart, onSingleTextNode, onMultiParts) {
+        const parts = parseTextAndParts(value, createPart);
+        if (parts.length === 1) {
+            if (parts[0]._tag === "text")
+                return onSingleTextNode(parts[0]);
+            return this.addPart(parts[0]);
+        }
+        return this.addPart(onMultiParts(parts));
+    }
+    addPart(part) {
+        this.parts.push([part, this.path.toChunk()]);
+        return part;
+    }
+    addPartWithPrevious(part) {
+        this.parts.push([part, this.path.previousChunk()]);
+        this.path.inc(); // Nodes will be inserted as a comment
+        return part;
+    }
+}
+const TEXT_ONLY_NODES_REGEX = new Set(["textarea", "script", "style", "title", "plaintext", "xmp"]);
+const SELF_CLOSING_TAGS = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "command",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "keygen",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+]);
+const TokenKind = {
+    /* eslint-disable @typescript-eslint/consistent-type-imports */
+    Literal: 0,
+    OpenTag: 1,
+    OpenTagEnd: 2,
+    CloseTag: 3,
+    Whitespace: 4,
+    AttrValueEq: 5,
+    AttrValueNq: 6,
+    AttrValueSq: 7,
+    AttrValueDq: 8,
+    /* eslint-enable @typescript-eslint/consistent-type-imports */
+};
+const TokenKindToName = {
+    [TokenKind.Literal]: "Literal",
+    [TokenKind.OpenTag]: "OpenTag",
+    [TokenKind.OpenTagEnd]: "OpenTagEnd",
+    [TokenKind.CloseTag]: "CloseTag",
+    [TokenKind.Whitespace]: "Whitespace",
+    [TokenKind.AttrValueEq]: "AttrValueEq",
+    [TokenKind.AttrValueNq]: "AttrValueNq",
+    [TokenKind.AttrValueSq]: "AttrValueSq",
+    [TokenKind.AttrValueDq]: "AttrValueDq",
+};
+function templateWithParts(template) {
+    const length = template.length;
+    if (length === 0)
+        return "";
+    // oxlint-disable-next-line no-new-array
+    const parts = new Array(length + length - 1);
+    let j = 0;
+    for (let i = 0; i < length; i++) {
+        parts[j++] = template[i];
+        if (i !== length - 1) {
+            parts[j++] = PART_STRING(i);
+        }
+    }
+    return parts.join("");
+}
+function parseTextAndParts(s, createPartFromIndex, onTextNodeInserted) {
+    const out = [];
+    let pos = 0;
+    let foundAny = false;
+    while (true) {
+        const start = s.indexOf("{{", pos);
+        if (start === -1)
+            break;
+        const end = s.indexOf("}}", start + 2);
+        if (end === -1)
+            break;
+        const before = s.slice(pos, start);
+        pos = end + 2;
+        // Before first part: skip whitespace-only. Between parts: only skip empty.
+        if (before !== "" && (foundAny || /\S/.test(before))) {
+            out.push(new Template.TextNode(before));
+            onTextNodeInserted?.();
+        }
+        foundAny = true;
+        out.push(createPartFromIndex(+s.slice(start + 2, end)));
+    }
+    const after = s.slice(pos);
+    // After last part (or entire string if no parts): skip whitespace-only
+    if (after !== "" && /\S/.test(after)) {
+        out.push(new Template.TextNode(after));
+        onTextNodeInserted?.();
+    }
+    return out;
+}
+// Only to be utilized when parsing positions which MUST be a single part.
+function unsafeParsePartIndex(text) {
+    return parseInt(text.slice(2, -2), 10);
+}
+function isSpreadAttribute(rawName) {
+    return rawName[0] === "." && rawName[1] === "." && rawName[2] === ".";
+}

package/dist/Render.d.ts

@@ -0,0 +1,195 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import { Fx } from "@typed/fx";
+import { type EventSource } from "./EventSource.js";
+import { HydrateContext } from "./HydrateContext.js";
+import type { HydrationTemplate } from "./internal/hydration.js";
+import { type IndexRefCounter } from "./internal/IndexRefCounter.js";
+import type { Renderable } from "./Renderable.js";
+import { type RenderEvent } from "./RenderEvent.js";
+import * as RQ from "./RenderQueue.js";
+import { RenderTemplate } from "./RenderTemplate.js";
+import { type Rendered } from "./Wire.js";
+/**
+ * A service that provides the `Document` interface for rendering.
+ *
+ * Defaults to the global `document` object. This can be overridden for testing
+ * or environments where the global document is not available or desired.
+ *
+ * @example
+ * ```ts
+ * import { CurrentRenderDocument } from "@typed/template/Render"
+ * import { Layer } from "effect"
+ *
+ * // Override document for testing
+ * const testDocument = new Document()
+ * const testLayer = Layer.succeed(CurrentRenderDocument, testDocument)
+ * ```
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare const CurrentRenderDocument: ServiceMap.Reference<Document>;
+/**
+ * A service that manages the queue of DOM updates.
+ *
+ * It ensures that DOM updates are batched and executed efficiently, often coordinating
+ * with browser painting cycles (e.g., via `requestAnimationFrame`).
+ *
+ * @example
+ * ```ts
+ * import { CurrentRenderQueue } from "@typed/template/Render"
+ * import { MixedRenderQueue } from "@typed/template/RenderQueue"
+ * import { Layer } from "effect"
+ *
+ * // Use a custom render queue
+ * const customQueue = new MixedRenderQueue()
+ * const queueLayer = Layer.succeed(CurrentRenderQueue, customQueue)
+ * ```
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare const CurrentRenderQueue: ServiceMap.Reference<RQ.RenderQueue>;
+/**
+ * A service that provides the default priority for rendering tasks.
+ *
+ * The default value is `RenderPriority.Raf(10)`, which typically schedules updates
+ * to occur before the next repaint.
+ *
+ * @example
+ * ```ts
+ * import { CurrentRenderPriority } from "@typed/template/Render"
+ * import { RenderPriority } from "@typed/template/RenderQueue"
+ * import { Layer } from "effect"
+ *
+ * // Use synchronous priority for immediate updates
+ * const syncLayer = Layer.succeed(CurrentRenderPriority, RenderPriority.Sync)
+ * ```
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare const CurrentRenderPriority: ServiceMap.Reference<number>;
+/**
+ * A Layer that provides the `RenderTemplate` service implemented for DOM rendering.
+ *
+ * This layer enables templates to be rendered as actual DOM nodes. It handles:
+ * - Parsing templates into DOM fragments.
+ * - Caching parsed templates.
+ * - Hydrating from existing DOM (if applicable).
+ * - Setting up event listeners.
+ * - Managing fine-grained updates to DOM nodes via `Fx` streams.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect"
+ * import { html } from "@typed/template"
+ * import { DomRenderTemplate, render } from "@typed/template/Render"
+ * import { Fx } from "@typed/fx"
+ *
+ * const program = Effect.gen(function* () {
+ *   const template = html`<div>Hello, world!</div>`
+ *
+ *   yield* render(template, document.body).pipe(
+ *     Fx.drainLayer,
+ *     Layer.provide(DomRenderTemplate),
+ *     Layer.launch
+ *   )
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const DomRenderTemplate: Layer.Layer<RenderTemplate, never, never> & {
+    readonly using: (document: Document) => Layer.Layer<RenderTemplate, never, never>;
+};
+/**
+ * A helper type to determine the rendered output type.
+ */
+export type ToRendered<T extends RenderEvent | null> = Rendered | (T extends null ? null : never);
+/**
+ * Mounts a reactive `Fx` stream of `RenderEvent`s to a specific DOM element.
+ *
+ * This function takes a stream of render events (usually from a template) and keeps
+ * the target DOM element updated. It handles:
+ * - Mounting the initial content.
+ * - Updating the content as new events are emitted.
+ * - Hydrating the content if hydration context is provided.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect"
+ * import { html } from "@typed/template"
+ * import { DomRenderTemplate, render } from "@typed/template/Render"
+ * import { Fx } from "@typed/fx"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   const template = html`<div>
+ *     <p>Count: ${count}</p>
+ *     <button onclick=${RefSubject.increment(count)}>Increment</button>
+ *   </div>`
+ *
+ *   // Render to document.body
+ *   yield* render(template, document.body).pipe(
+ *     Fx.drainLayer,
+ *     Layer.provide(DomRenderTemplate),
+ *     Layer.launch
+ *   )
+ * })
+ *
+ * // Can also use pipe syntax
+ * const program2 = Effect.gen(function* () {
+ *   const template = html`<div>Hello</div>`
+ *
+ *   yield* template.pipe(
+ *     render(document.body),
+ *     Fx.drainLayer,
+ *     Layer.provide(DomRenderTemplate),
+ *     Layer.launch
+ *   )
+ * })
+ * ```
+ *
+ * @param fx - The `Fx` stream of content to render.
+ * @param where - The target DOM element to render into.
+ * @returns An `Fx` that emits the currently rendered DOM nodes.
+ * @since 1.0.0
+ * @category rendering
+ */
+export declare const render: {
+    (where: HTMLElement): <A extends RenderEvent | null, E, R>(fx: Fx.Fx<A, E, R>) => Fx.Fx<ToRendered<A>, E, R>;
+    <A extends RenderEvent | null, E, R>(fx: Fx.Fx<A, E, R>, where: HTMLElement): Fx.Fx<ToRendered<A>, E, R>;
+};
+export type TemplateContext<R = never> = {
+    readonly document: Document;
+    readonly renderQueue: RQ.RenderQueue;
+    readonly disposables: Set<Disposable>;
+    readonly eventSource: EventSource;
+    readonly refCounter: IndexRefCounter;
+    readonly scope: Scope.Closeable;
+    readonly values: ArrayLike<Renderable<unknown, any, any>>;
+    readonly services: ServiceMap.ServiceMap<R | Scope.Scope>;
+    readonly onCause: (cause: Cause.Cause<any>) => Effect.Effect<unknown>;
+    /**
+     * @internal
+     */
+    expected: number;
+    /**
+     * @internal
+     */
+    dynamicIndex: number;
+    readonly hydrateContext: HydrateContext | undefined;
+};
+export declare function attemptHydration(ctx: TemplateContext, hash: string): {
+    readonly where: HydrationTemplate;
+    readonly hydrateCtx: HydrateContext;
+} | undefined;
+//# sourceMappingURL=Render.d.ts.map

package/dist/Render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Render.d.ts","sourceRoot":"","sources":["../src/Render.ts"],"names":[],"mappings":"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"}