@typed/template 0.14.0 → 1.0.0-beta.1

package/dist/internal/buildTemplateFragement.js

@@ -0,0 +1,61 @@
+export function buildTemplateFragment(document, template) {
+    const root = document.createDocumentFragment();
+    for (const node of template.nodes) {
+        root.appendChild(buildTemplateNode(document, node));
+    }
+    return root;
+}
+function buildTemplateNode(document, node) {
+    switch (node._tag) {
+        case "comment":
+            return document.createComment(node.value);
+        case "comment-part":
+            return document.createComment(`c_${node.index}`);
+        case "sparse-comment": {
+            return document.createComment(`c_${node.nodes.map((n) => (n._tag === "text" ? "" : n.index)).join("_")}`);
+        }
+        case "doctype":
+            return document.implementation.createDocumentType(node.name, node.publicId ?? "", node.systemId ?? "");
+        case "element":
+            return buildTemplateElement(document, node);
+        case "self-closing-element":
+            return buildTemplateSelfClosingElement(document, node);
+        case "text-only-element":
+            return buildTemplateTextOnlyElement(document, node);
+        case "text":
+            return document.createTextNode(node.value);
+        case "node":
+            return document.createComment(`/n_${node.index}`);
+    }
+}
+function buildTemplateElement(document, node) {
+    const element = document.createElement(node.tagName);
+    addStaticAttributes(element, node.attributes);
+    for (const child of node.children) {
+        element.appendChild(buildTemplateNode(document, child));
+    }
+    return element;
+}
+function addStaticAttributes(element, attributes) {
+    for (const attribute of attributes) {
+        if (attribute._tag === "attribute") {
+            element.setAttribute(attribute.name, attribute.value);
+        }
+        else if (attribute._tag === "boolean") {
+            element.toggleAttribute(attribute.name, true);
+        }
+    }
+}
+function buildTemplateSelfClosingElement(document, node) {
+    const element = document.createElement(node.tagName);
+    addStaticAttributes(element, node.attributes);
+    return element;
+}
+function buildTemplateTextOnlyElement(document, node) {
+    const element = document.createElement(node.tagName);
+    addStaticAttributes(element, node.attributes);
+    if (node.textContent && node.textContent._tag === "text") {
+        element.textContent = node.textContent.value;
+    }
+    return element;
+}

package/dist/internal/diff.d.ts

@@ -0,0 +1,2 @@
+export declare const diff: (a: Array<Node>, b: Array<Node>, get: (entry: Node, action: number) => Node, before: Node) => Node[];
+//# sourceMappingURL=diff.d.ts.map

package/dist/internal/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/internal/diff.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,GACf,GAAG,KAAK,CAAC,IAAI,CAAC,EACd,GAAG,KAAK,CAAC,IAAI,CAAC,EACd,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,EAC1C,QAAQ,IAAI,WAwHb,CAAC"}

package/dist/internal/diff.js

@@ -0,0 +1,119 @@
+// @see https://github.com/WebReflection/udomdiff
+export const diff = (a, b, get, before) => {
+    const parentNode = before.parentNode;
+    const bLength = b.length;
+    let aEnd = a.length;
+    let bEnd = bLength;
+    let aStart = 0;
+    let bStart = 0;
+    let map = null;
+    while (aStart < aEnd || bStart < bEnd) {
+        // append head, tail, or nodes in between: fast path
+        if (aEnd === aStart) {
+            // we could be in a situation where the rest of nodes that
+            // need to be added are not at the end, and in such case
+            // the node to `insertBefore`, if the index is more than 0
+            // must be retrieved, otherwise it's gonna be the first item.
+            const node = bEnd < bLength ? (bStart ? get(b[bStart - 1], -0).nextSibling : get(b[bEnd], 0)) : before;
+            while (bStart < bEnd) {
+                parentNode.insertBefore(get(b[bStart++], 1), node);
+            }
+        } // remove head or tail: fast path
+        else if (bEnd === bStart) {
+            while (aStart < aEnd) {
+                // remove the node only if it's unknown or not live
+                if (!map || !map.has(a[aStart])) {
+                    // @ts-ignore
+                    get(a[aStart], -1).remove();
+                }
+                aStart++;
+            }
+        } // same node: fast path
+        else if (a[aStart] === b[bStart]) {
+            aStart++;
+            bStart++;
+        } // same tail: fast path
+        else if (a[aEnd - 1] === b[bEnd - 1]) {
+            aEnd--;
+            bEnd--;
+        } // The once here single last swap "fast path" has been removed in v1.1.0
+        // https://github.com/WebReflection/udomdiff/blob/single-final-swap/esm/index.js#L69-L85
+        // reverse swap: also fast path
+        else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+            // this is a "shrink" operation that could happen in these cases:
+            // [1, 2, 3, 4, 5]
+            // [1, 4, 3, 2, 5]
+            // or asymmetric too
+            // [1, 2, 3, 4, 5]
+            // [1, 2, 3, 5, 6, 4]
+            const node = get(a[--aEnd], -0).nextSibling;
+            parentNode.insertBefore(get(b[bStart++], 1), get(a[aStart++], -0).nextSibling);
+            parentNode.insertBefore(get(b[--bEnd], 1), node);
+            // mark the future index as identical (yeah, it's dirty, but cheap 👍)
+            // The main reason to do this, is that when a[aEnd] will be reached,
+            // the loop will likely be on the fast path, as identical to b[bEnd].
+            // In the best case scenario, the next loop will skip the tail,
+            // but in the worst one, this node will be considered as already
+            // processed, bailing out pretty quickly from the map index check
+            a[aEnd] = b[bEnd];
+        } // map based fallback, "slow" path
+        else {
+            // the map requires an O(bEnd - bStart) operation once
+            // to store all future nodes indexes for later purposes.
+            // In the worst case scenario, this is a full O(N) cost,
+            // and such scenario happens at least when all nodes are different,
+            // but also if both first and last items of the lists are different
+            if (!map) {
+                map = new Map();
+                let i = bStart;
+                while (i < bEnd) {
+                    map.set(b[i], i++);
+                }
+            }
+            const index = map.get(a[aStart]) ?? -1;
+            // this node has no meaning in the future list, so it's more than safe
+            // to remove it, and check the next live node out instead, meaning
+            // that only the live list index should be forwarded
+            if (index < 0)
+                get(a[aStart++], -1).remove();
+            // it's a future node, hence it needs some handling
+            else {
+                // if it's not already processed, look on demand for the next LCS
+                if (bStart < index && index < bEnd) {
+                    let i = aStart;
+                    // counts the amount of nodes that are the same in the future
+                    let sequence = 1;
+                    while (++i < aEnd && i < bEnd && map.get(a[i]) === index + sequence) {
+                        sequence++;
+                    }
+                    // effort decision here: if the sequence is longer than replaces
+                    // needed to reach such sequence, which would brings again this loop
+                    // to the fast path, prepend the difference before a sequence,
+                    // and move only the future list index forward, so that aStart
+                    // and bStart will be aligned again, hence on the fast path.
+                    // An example considering aStart and bStart are both 0:
+                    // a: [1, 2, 3, 4]
+                    // b: [7, 1, 2, 3, 6]
+                    // this would place 7 before 1 and, from that time on, 1, 2, and 3
+                    // will be processed at zero cost
+                    if (sequence > index - bStart) {
+                        const node = get(a[aStart], 0);
+                        while (bStart < index) {
+                            parentNode.insertBefore(get(b[bStart++], 1), node);
+                        }
+                    } // if the effort wasn't good enough, fallback to a replace,
+                    // moving both source and target indexes forward, hoping that some
+                    // similar node will be found later on, to go back to the fast path
+                    else {
+                        // TODO: benchmark replaceWith instead
+                        parentNode.replaceChild(get(b[bStart++], 1), get(a[aStart++], -1));
+                    }
+                } // otherwise move the source forward, 'cause there's nothing to do
+                else {
+                    aStart++;
+                }
+            }
+        }
+    }
+    return b;
+};

package/dist/internal/dom.d.ts

@@ -0,0 +1,45 @@
+import { type EventHandler } from "../EventHandler.js";
+export declare function makeTextContentUpdater(element: Node): (value: unknown) => void;
+export declare function makeAttributeValueUpdater(element: HTMLElement | SVGElement, attr: Attr): (value: string | null | undefined) => void;
+export declare function makeClassListUpdater(element: HTMLElement | SVGElement): (classNames: ReadonlyArray<string>) => void;
+export declare function makeDatasetUpdater(element: HTMLElement | SVGElement): (value: unknown) => void;
+export declare function diffStrings(previous: ReadonlyArray<string> | null | undefined, current: ReadonlyArray<string> | null | undefined): {
+    added: ReadonlyArray<string>;
+    removed: ReadonlyArray<string>;
+    unchanged: ReadonlyArray<string>;
+};
+export declare function diffDataSet(a: Record<string, string | undefined> | null | undefined, b: Record<string, string | undefined> | null | undefined): {
+    added: Array<readonly [string, string | undefined]>;
+    removed: ReadonlyArray<string>;
+} | null;
+export declare function getClassList(value: unknown): ReadonlyArray<string>;
+/**
+ * Splits a string of class names (like those used in HTML `class=""` attributes)
+ * into an array of individual class names (words), separated by whitespace.
+ *
+ * This function avoids creating intermediate arrays and unnecessary string copying by:
+ *   - Scanning the string one character at a time
+ *   - Skipping over all leading whitespace for each word
+ *   - Collecting all consecutive non-whitespace characters as a "word"
+ *   - Repeating until the input is exhausted
+ *
+ * All ASCII "whitespace" characters with code <= 32 are considered as delimiters.
+ * This is more efficient than `String.prototype.trim` and `String.prototype.split(/\s+/)`
+ * as it only allocates memory for the result array, not for intermediate or empty strings.
+ *
+ * Example:
+ *    splitClassNames("  foo   bar\tbaz\nqux  ") // => ["foo", "bar", "baz", "qux"]
+ */
+export declare function splitClassNames(value: string): Array<string>;
+export declare function matchNodeValue<A, B>(document: Document, value: unknown, onText: (text: string) => A, onNodes: (nodes: Array<Node>) => B): A | B;
+export declare function renderEventToArray(document: Document, x: unknown): Array<Node>;
+export declare function diffChildren(comment: Comment, currentNodes: Array<Node>, nextNodes: Array<Node>, get: (entry: Node, action: number) => Node): Node[];
+export declare function findNodePartEndComment(parent: Element, index: number): Comment;
+export declare function findNodePartStartComment(parent: Element, index: number): Comment;
+export declare function makeNodeUpdater(document: Document, comment: Comment, text?: Text | null, nodes?: Array<Node>): (value: unknown) => void;
+export declare function makeBooleanUpdater(element: HTMLElement | SVGElement, name: string): (value: boolean) => void;
+export declare function getAttributeValue(value: unknown): string | null | undefined;
+export declare function getBooleanValue(value: unknown): boolean;
+export declare function getDatasetValue(value: unknown): Record<string, string | undefined> | null | undefined;
+export declare function getEventHandlerValue<E, R>(value: unknown): EventHandler<Event, E, R> | null | undefined;
+//# sourceMappingURL=dom.d.ts.map

package/dist/internal/dom.d.ts.map

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

package/dist/internal/dom.js

@@ -0,0 +1,304 @@
+import * as Effect from "effect/Effect";
+import { isNullish, isObject } from "effect/Predicate";
+import { CouldNotFindCommentError } from "../errors.js";
+import { fromEffectOrEventHandler, isEventHandler } from "../EventHandler.js";
+import { isRenderEvent, RenderEventTypeId, } from "../RenderEvent.js";
+import { diffable, isComment } from "../Wire.js";
+import { diff } from "./diff.js";
+import { renderToString } from "./encoding.js";
+export function makeTextContentUpdater(element) {
+    return (value) => {
+        element.textContent = renderToString(value, "");
+    };
+}
+export function makeAttributeValueUpdater(element, attr) {
+    let isSet = false;
+    const setValue = (value) => {
+        if (isNullish(value)) {
+            element.removeAttribute(attr.name);
+            isSet = false;
+        }
+        else {
+            attr.value = value;
+            if (isSet === false) {
+                element.setAttributeNode(attr);
+                isSet = true;
+            }
+        }
+    };
+    return setValue;
+}
+export function makeClassListUpdater(element) {
+    // We do double-bookeeping such that we don't assume we know everything about the classList
+    // Other DOM-based libraries might have additional classes in the classList, so we need to allow them to exist
+    // outside of our control.
+    let classList = Array.from(element.classList);
+    return (classNames) => {
+        const { added, removed } = diffStrings(classList, classNames);
+        if (added.length > 0) {
+            element.classList.add(...added);
+        }
+        if (removed.length > 0) {
+            element.classList.remove(...removed);
+        }
+        classList = classNames;
+    };
+}
+export function makeDatasetUpdater(element) {
+    // We do double-bookeeping such that we don't assume we know everything about the dataset
+    // Other DOM-based libraries might have additional keys in the dataset, so we need to allow them to exist
+    // outside of our control.
+    const previous = { ...element.dataset };
+    return (value) => {
+        const diff = diffDataSet(previous, value);
+        if (diff) {
+            const { added, removed } = diff;
+            removed.forEach((k) => {
+                delete element.dataset[k];
+                delete previous[k];
+            });
+            added.forEach(([k, v]) => {
+                element.dataset[k] = v;
+                previous[k] = v;
+            });
+        }
+    };
+}
+export function diffStrings(previous, current) {
+    if (previous == null || previous.length === 0) {
+        return {
+            added: current || [],
+            removed: [],
+            unchanged: [],
+        };
+    }
+    else if (current == null || current.length === 0) {
+        return {
+            added: [],
+            removed: previous,
+            unchanged: [],
+        };
+    }
+    else {
+        const previousSet = new Set(previous);
+        const currentSet = new Set(current);
+        const added = current.filter((c) => !previousSet.has(c));
+        const removed = [];
+        const unchanged = [];
+        for (let i = 0; i < previous.length; ++i) {
+            if (currentSet.has(previous[i])) {
+                unchanged.push(previous[i]);
+            }
+            else {
+                removed.push(previous[i]);
+            }
+        }
+        return {
+            added,
+            removed,
+            unchanged,
+        };
+    }
+}
+export function diffDataSet(a, b) {
+    if (!a)
+        return b ? { added: Object.entries(b), removed: [] } : null;
+    if (!b)
+        return { added: [], removed: Object.keys(a) };
+    const { added, removed, unchanged } = diffStrings(Object.keys(a), Object.keys(b));
+    return {
+        added: added.concat(unchanged).map((k) => [k, b[k]]),
+        removed,
+    };
+}
+export function getClassList(value) {
+    if (isNullish(value))
+        return [];
+    if (Array.isArray(value))
+        return value.flatMap(getClassList);
+    return splitClassNames(renderToString(value, ""));
+}
+const ASCII_SPACE_CODE = 32;
+/**
+ * Splits a string of class names (like those used in HTML `class=""` attributes)
+ * into an array of individual class names (words), separated by whitespace.
+ *
+ * This function avoids creating intermediate arrays and unnecessary string copying by:
+ *   - Scanning the string one character at a time
+ *   - Skipping over all leading whitespace for each word
+ *   - Collecting all consecutive non-whitespace characters as a "word"
+ *   - Repeating until the input is exhausted
+ *
+ * All ASCII "whitespace" characters with code <= 32 are considered as delimiters.
+ * This is more efficient than `String.prototype.trim` and `String.prototype.split(/\s+/)`
+ * as it only allocates memory for the result array, not for intermediate or empty strings.
+ *
+ * Example:
+ *    splitClassNames("  foo   bar\tbaz\nqux  ") // => ["foo", "bar", "baz", "qux"]
+ */
+export function splitClassNames(value) {
+    const result = [];
+    let start = 0;
+    const len = value.length;
+    while (start < len) {
+        // Skip leading whitespace (all ASCII <= 32)
+        while (start < len && value.charCodeAt(start) <= ASCII_SPACE_CODE)
+            start++;
+        if (start >= len)
+            break;
+        // Find the end of the word (next whitespace)
+        let end = start + 1;
+        while (end < len && value.charCodeAt(end) > ASCII_SPACE_CODE)
+            end++;
+        result.push(value.slice(start, end));
+        // Move start past the end of the last word (one char after end)
+        start = end + 1;
+    }
+    return result;
+}
+export function matchNodeValue(document, value, onText, onNodes) {
+    switch (typeof value) {
+        // primitives are handled as text content
+        case "string":
+        case "symbol":
+        case "number":
+        case "bigint":
+        case "boolean":
+            return onText(String(value));
+        case "undefined":
+        case "function":
+        case "object": {
+            if (isNullish(value)) {
+                return onNodes([]);
+            }
+            else if (isRenderEvent(value)) {
+                return onNodes(unwrapRenderEvent(document, value));
+            }
+            else if (Array.isArray(value)) {
+                return onNodes(value.flatMap((_) => renderEventToArray(document, _)));
+            }
+            else {
+                return onNodes(renderEventToArray(document, value));
+            }
+        }
+    }
+}
+export function renderEventToArray(document, x) {
+    switch (typeof x) {
+        case "string":
+        case "number":
+        case "bigint":
+        case "boolean":
+        case "symbol":
+            return [document.createTextNode(String(x))];
+        case "undefined":
+        case "function":
+        case "object":
+            if (isNullish(x))
+                return [];
+            if (isRenderEvent(x))
+                return unwrapRenderEvent(document, x);
+            if (Array.isArray(x))
+                return x.flatMap((_) => renderEventToArray(document, _));
+            return [x];
+        default:
+            return [];
+    }
+}
+function unwrapRenderEvent(document, x) {
+    if (x[RenderEventTypeId] === "dom")
+        return unwrapDomRenderEvent(x);
+    return unwrapHtmlRenderEvent(document, x);
+}
+function unwrapDomRenderEvent(x) {
+    const value = x.content;
+    return Array.isArray(value) ? value : [value];
+}
+function unwrapHtmlRenderEvent(document, x) {
+    const tmp = document.createElement("template");
+    tmp.innerHTML = x.html;
+    return Array.from(tmp.childNodes);
+}
+export function diffChildren(comment, currentNodes, nextNodes, get) {
+    return diff(currentNodes, nextNodes, get, comment);
+}
+const commentCache = new WeakMap();
+function getCommentCacheKey(index, isEnd) {
+    return isEnd ? -index - 1 : index;
+}
+function findCommentInElement(parent, index, isEnd) {
+    let cache = commentCache.get(parent);
+    if (cache === undefined) {
+        cache = new Map();
+        commentCache.set(parent, cache);
+    }
+    const cacheKey = getCommentCacheKey(index, isEnd);
+    const cached = cache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const childNodes = parent.childNodes;
+    const searchValue = isEnd ? `/n_${index}` : `n_${index}`;
+    for (let i = 0; i < childNodes.length; ++i) {
+        const node = childNodes[i];
+        if (isCommentWithValue(node, searchValue)) {
+            cache.set(cacheKey, node);
+            return node;
+        }
+    }
+    throw new CouldNotFindCommentError(index);
+}
+export function findNodePartEndComment(parent, index) {
+    return findCommentInElement(parent, index, true);
+}
+export function findNodePartStartComment(parent, index) {
+    return findCommentInElement(parent, index, false);
+}
+function isCommentWithValue(node, value) {
+    return isComment(node) && node.nodeValue === value;
+}
+export function makeNodeUpdater(document, comment, text = null, nodes = []) {
+    const element = comment.parentNode;
+    const get = diffable(document);
+    const updateCommentText = (value) => {
+        if (text === null) {
+            text = document.createTextNode("");
+            element.insertBefore(text, comment);
+        }
+        text.textContent = renderToString(value, "");
+        nodes = diffChildren(comment, nodes, [text], get);
+    };
+    const updateNodes = (updatedNodes) => {
+        nodes = diffChildren(comment, nodes, updatedNodes, get);
+    };
+    return (value) => {
+        matchNodeValue(document, value, updateCommentText, updateNodes);
+    };
+}
+export function makeBooleanUpdater(element, name) {
+    return (value) => {
+        element.toggleAttribute(name, value);
+    };
+}
+export function getAttributeValue(value) {
+    if (isNullish(value))
+        return null;
+    return renderToString(value, "");
+}
+export function getBooleanValue(value) {
+    return !!value;
+}
+export function getDatasetValue(value) {
+    if (isNullish(value))
+        return null;
+    if (isObject(value))
+        return value;
+    return null;
+}
+export function getEventHandlerValue(value) {
+    if (isNullish(value))
+        return null;
+    if (isEventHandler(value) || Effect.isEffect(value))
+        return fromEffectOrEventHandler(value);
+    return null;
+}

package/dist/internal/encoding.d.ts

@@ -0,0 +1,7 @@
+export declare function escape(s: unknown): string;
+export declare function unescape(s: string): any;
+export declare function escapeHtml(str: string): string;
+export declare function unescapeHtml(html: string): string;
+export declare function renderToString(value: unknown, delimiter?: string): string;
+export declare function renderToEscapedString(value: unknown, delimiter: string): string;
+//# sourceMappingURL=encoding.d.ts.map

package/dist/internal/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/internal/encoding.ts"],"names":[],"mappings":"AAIA,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAuBzC;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,OAYjC;AAaD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA8C9C;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,UAMxC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,MAAW,GAAG,MAAM,CAgC7E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/E"}