@esportsplus/template 0.15.20 → 0.17.0

package/src/slot/reactive.ts

@@ -0,0 +1,167 @@
+import { root, ReactiveArray } from '@esportsplus/reactivity';
+import { EMPTY_FRAGMENT } from '~/constants';
+import { Fragment, RenderableReactive, SlotGroup } from '~/types';
+import { append, cloneNode, firstChild, lastChild } from '~/utilities';
+import { remove } from './cleanup';
+
+
+class ReactiveArraySlot<T> {
+    array: ReactiveArray<T[]>;
+    fragment = cloneNode.call(EMPTY_FRAGMENT) as Fragment;
+    marker: Element;
+    nodes: SlotGroup[] = [];
+    template: (
+        this: ReactiveArray<T[]>,
+        ...args: Parameters< Parameters<ReactiveArray<T[]>['map']>[0] >
+    ) => SlotGroup;
+
+
+    constructor(anchor: Element, array: ReactiveArray<T[]>, template: RenderableReactive['template']) {
+        let fragment = this.fragment;
+
+        this.array = array;
+        this.marker = anchor;
+        this.template = function (data, i) {
+            let frag = template.call(this, data, i).fragment,
+                group = {
+                    head: firstChild.call(frag),
+                    tail: lastChild.call(frag)
+                };
+
+            append.call(fragment, frag);
+
+            return group;
+        };
+
+
+        let render = () => {
+                root(() => this.render());
+            };
+
+        array.on('clear', () => this.clear());
+        array.on('reverse', render);
+        array.on('pop', () => this.pop());
+        array.on('push', ({ items }) => {
+            root(() => this.push(items));
+        });
+        array.on('shift', () => this.shift());
+        array.on('sort', render);
+        array.on('splice', ({ deleteCount, items, start }) => {
+            root(() => this.splice(start, deleteCount, ...items));
+        });
+        array.on('unshift', ({ items }) => {
+            root(() => this.unshift(items));
+        });
+
+        if (array.length) {
+            render();
+        }
+    }
+
+
+    get length() {
+        return this.nodes.length;
+    }
+
+    set length(n: number) {
+        if (n >= this.nodes.length) {
+            return;
+        }
+        else if (n === 0) {
+            this.clear();
+        }
+        else {
+            this.splice(n);
+        }
+    }
+
+
+    anchor(index: number = this.nodes.length - 1) {
+        let node = this.nodes[index];
+
+        if (node) {
+            return node.tail || node.head;
+        }
+
+        return this.marker;
+    }
+
+    clear() {
+        remove(this.nodes);
+    }
+
+    pop() {
+        let group = this.nodes.pop();
+
+        if (group) {
+            remove([group]);
+        }
+    }
+
+    push(items: T[]) {
+        let anchor = this.anchor(),
+            array = this.array;
+
+        for (let i = 0, n = items.length; i < n; i++) {
+            this.nodes.push(
+                this.template.call(array, items[i], i)
+            );
+        }
+
+        anchor.after(this.fragment);
+    }
+
+    render() {
+        let nodes = this.nodes;
+
+        if (nodes.length) {
+            remove(nodes);
+        }
+
+        nodes = this.array.map(this.template);
+        this.marker.after(this.fragment);
+    }
+
+    shift() {
+        let group = this.nodes.shift();
+
+        if (group) {
+            remove([group]);
+        }
+    }
+
+    splice(start: number, stop: number = this.nodes.length, ...items: T[]) {
+        if (!items.length) {
+            return remove(this.nodes.splice(start, stop));
+        }
+
+        let array = this.array,
+            n = items.length,
+            nodes = new Array(n);
+
+        for (let i = 0; i < n; i++) {
+            nodes[i] = this.template.call(array, items[i], i);
+        }
+
+        remove(this.nodes.splice(start, stop, ...nodes));
+        this.anchor(start - 1).after(this.fragment);
+    }
+
+    unshift(items: T[]) {
+        let array = this.array,
+            n = items.length,
+            nodes = new Array(n);
+
+        for (let i = 0; i < n; i++) {
+            nodes[i] = this.template.call(array, items[i], i);
+        }
+
+        this.nodes.unshift(...nodes);
+        this.marker.after(this.fragment);
+    }
+}
+
+
+export default (anchor: Element, renderable: RenderableReactive) => {
+    new ReactiveArraySlot(anchor, renderable.array, renderable.template);
+};

package/src/slot/render.ts

@@ -0,0 +1,81 @@
+import { isArray } from '@esportsplus/utilities';
+import {
+    RENDERABLE,
+    RENDERABLE_ARRAY, RENDERABLE_FRAGMENT, RENDERABLE_HTML_FRAGMENT, RENDERABLE_HTML_REACTIVE_ARRAY,
+    RENDERABLE_NODE, RENDERABLE_NODE_LIST, RENDERABLE_TEXT, RENDERABLE_VOID
+} from '~/constants';
+import { Element, Fragment, RenderableReactive, RenderableTemplate } from '~/types';
+import { append, text } from '~/utilities';
+import reactive from './reactive';
+
+
+function type(input: unknown) {
+    if (input === false || input == null || input === '') {
+        return RENDERABLE_VOID;
+    }
+
+    if (typeof input !== 'object') {
+        return RENDERABLE_TEXT;
+    }
+
+    if (RENDERABLE in input) {
+        return input[RENDERABLE];
+    }
+
+    if (isArray(input)) {
+        return RENDERABLE_ARRAY;
+    }
+
+    let nodeType = (input as any).nodeType;
+
+    if (nodeType === 11) {
+        return RENDERABLE_FRAGMENT;
+    }
+
+    if (nodeType !== undefined) {
+        return RENDERABLE_NODE;
+    }
+
+    if (input instanceof NodeList) {
+        return RENDERABLE_NODE_LIST;
+    }
+}
+
+
+export default function render(anchor: Element, fragment: Fragment, input: unknown) {
+    let t = type(input);
+
+    switch (t) {
+        case RENDERABLE_VOID:
+            return;
+
+        case RENDERABLE_TEXT:
+            append.call(fragment, text(String(input)));
+            return;
+
+        case RENDERABLE_HTML_FRAGMENT:
+            append.call(fragment, (input as RenderableTemplate).fragment);
+            return;
+
+        case RENDERABLE_HTML_REACTIVE_ARRAY:
+            return reactive(anchor, input as RenderableReactive);
+
+        case RENDERABLE_ARRAY:
+            for (let i = 0, n = (input as unknown[]).length; i < n; i++) {
+                render(anchor, fragment, (input as unknown[])[i]);
+            }
+            return;
+
+        case RENDERABLE_FRAGMENT:
+            append.call(fragment, input as Fragment);
+            return;
+
+        case RENDERABLE_NODE:
+            append.call(fragment, input as Node);
+            return;
+
+        case RENDERABLE_NODE_LIST:
+            append.call(fragment, ...(input as NodeList));
+            return;
+    }
+};

package/src/svg.ts

@@ -1,9 +1,8 @@
 import html from './html';
-import { RenderableTemplate } from './types';
 
 
 const svg = html.bind(null) as typeof html & {
-    sprite: <T>(symbol: string) => RenderableTemplate<T>
+    sprite: (symbol: string) => ReturnType<typeof html>
 };
 
 svg.sprite = (symbol: string) => {

package/src/types.ts

@@ -1,8 +1,9 @@
 import { ReactiveArray } from '@esportsplus/reactivity';
-import { RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE } from './constants';
+import { RENDERABLE, RENDERABLE_HTML_FRAGMENT, RENDERABLE_HTML_REACTIVE_ARRAY } from './constants';
 import { firstChild } from './utilities';
 import attributes from './attributes';
 import slot from './slot';
+import html from './html';
 
 
 type Attribute = Primitive | Effect<Primitive | Primitive[]>;
@@ -24,38 +25,43 @@ type Attributes = {
 
 type Effect<T> = () => EffectResponse<T>;
 
-type EffectResponse<T> = T extends [] ? EffectResponse<T[number]>[] : Primitive | Renderable<T>;
+type EffectResponse<T> = T extends [] ? (Primitive | Renderable)[] : Primitive | Renderable;
 
 type Element = HTMLElement & Attributes & Record<PropertyKey, unknown>;
 
 type Elements = Element[];
 
-type HydrateResult = { elements: Elements, fragment: DocumentFragment | Node };
+type Fragment = (DocumentFragment | Node) & Record<PropertyKey, unknown>;
 
 // Copied from '@esportsplus/utilities'
 // - Importing from ^ causes 'cannot be named without a reference to...' error
 type Primitive = bigint | boolean | null | number | string | undefined;
 
-type Renderable<T = unknown> = RenderableReactive<T> | RenderableTemplate<T>;
+type Renderable = Fragment | RenderableReactive;
 
-type RenderableReactive<T = unknown> = Readonly<{
-    [RENDERABLE]: typeof RENDERABLE_REACTIVE;
-    literals: null;
+type RenderableReactive = Readonly<{
+    [RENDERABLE]: typeof RENDERABLE_HTML_REACTIVE_ARRAY;
+    array: ReactiveArray<unknown[]>;
     template: (
-        this: ThisParameterType< Parameters<ReactiveArray<T>['map']>[0] >,
-        ...args: Parameters< Parameters<ReactiveArray<T>['map']>[0] >
-    ) => RenderableTemplate<T>;
-    values: ReactiveArray<T>;
+        this: ReactiveArray<unknown[]>,
+        ...args: Parameters< Parameters<ReactiveArray<unknown[]>['map']>[0] >
+    ) => ReturnType<typeof html>;
 }>;
 
-type RenderableTemplate<T> = {
-    [RENDERABLE]: typeof RENDERABLE_TEMPLATE;
+type RenderableTemplate = {
+    [RENDERABLE]: typeof RENDERABLE_HTML_FRAGMENT;
+    fragment: Fragment;
     literals: TemplateStringsArray;
-    template: Template | null;
-    values: (RenderableValue<T> | RenderableValue<T>[])[];
 };
 
-type RenderableValue<T = unknown> = Attributes | Readonly<Attributes> | Readonly<Attributes[]> | Effect<T> | Primitive | Renderable;
+type RenderableValue<T = unknown> = Attributes | Readonly<Attributes> | Readonly<Attributes[]> | Effect<T> | Fragment | Primitive | RenderableReactive;
+
+type RenderableValues = RenderableValue | RenderableValue[];
+
+type SlotGroup = {
+    head: Element;
+    tail: Element;
+};
 
 type Template = {
     fragment: DocumentFragment;
@@ -63,8 +69,11 @@ type Template = {
     literals: TemplateStringsArray;
     slots: {
         fn: typeof attributes.spread | typeof slot;
-        parent: typeof firstChild[];
-        path: typeof firstChild[];
+        path: {
+            absolute: typeof firstChild[],
+            parent: typeof firstChild[],
+            relative: typeof firstChild[]
+        };
         slot: number;
     }[] | null;
 };
@@ -73,7 +82,8 @@ type Template = {
 export type {
     Attributes,
     Effect, Element, Elements,
-    HydrateResult,
-    Renderable, RenderableReactive, RenderableTemplate, RenderableValue,
+    Fragment,
+    Renderable, RenderableReactive, RenderableTemplate, RenderableValue, RenderableValues,
+    SlotGroup,
     Template
 };

package/src/utilities.ts

@@ -2,7 +2,8 @@ import { micro as m, raf as r } from '@esportsplus/tasks';
 import { Element as E } from './types';
 
 
-let prototype,
+let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,
+    prototype,
     template = document.createElement('template'),
     t = document.createTextNode('');
 
@@ -18,15 +19,13 @@ const addEventListener = prototype.addEventListener;
 
 const removeEventListener = prototype.removeEventListener;
 
-const className = Object.getOwnPropertyDescriptor(prototype, 'className')!.set!;
+const className = getOwnPropertyDescriptor(prototype, 'className')!.set!;
 
-const innerHTML = Object.getOwnPropertyDescriptor(prototype, 'innerHTML')!.set!;
+const innerHTML = getOwnPropertyDescriptor(prototype, 'innerHTML')!.set!;
 
-const firstElementChild = Object.getOwnPropertyDescriptor(prototype, 'firstElementChild')!.get!;
+const firstElementChild = getOwnPropertyDescriptor(prototype, 'firstElementChild')!.get!;
 
-const nextElementSibling = Object.getOwnPropertyDescriptor(prototype, 'nextElementSibling')!.get!;
-
-const prepend = prototype.prepend;
+const nextElementSibling = getOwnPropertyDescriptor(prototype, 'nextElementSibling')!.get!;
 
 const removeAttribute = prototype.removeAttribute;
 
@@ -37,15 +36,17 @@ prototype = Node.prototype;
 
 const cloneNode = prototype.cloneNode;
 
-const firstChild = Object.getOwnPropertyDescriptor(prototype, 'firstChild')!.get!;
+const firstChild = getOwnPropertyDescriptor(prototype, 'firstChild')!.get!;
+
+const lastChild = getOwnPropertyDescriptor(prototype, 'lastChild')!.get!;
 
-const nextSibling = Object.getOwnPropertyDescriptor(prototype, 'nextSibling')!.get!;
+const nextSibling = getOwnPropertyDescriptor(prototype, 'nextSibling')!.get!;
 
-const nodeValue = Object.getOwnPropertyDescriptor(prototype, 'nodeValue')!.set!;
+const nodeValue = getOwnPropertyDescriptor(prototype, 'nodeValue')!.set!;
 
-const parentElement = Object.getOwnPropertyDescriptor(prototype, 'parentElement')!.get!;
+const parentElement = getOwnPropertyDescriptor(prototype, 'parentElement')!.get!;
 
-const parentNode = Object.getOwnPropertyDescriptor(prototype, 'parentNode')!.get!;
+const previousSibling = getOwnPropertyDescriptor(prototype, 'previousSibling')!.get!;
 
 
 const fragment = (html: string) => {
@@ -78,9 +79,10 @@ export {
     className, cloneNode,
     firstChild, firstElementChild, fragment,
     innerHTML,
+    lastChild,
     microtask,
     nextElementSibling, nextSibling, nodeValue,
-    parentElement, parentNode, prepend,
+    parentElement, previousSibling,
     raf, removeAttribute, removeEventListener,
     setAttribute,
     text

package/build/slot.d.ts

@@ -1,21 +0,0 @@
-import { Element, Elements, HydrateResult } from './types.js';
-declare class Slot {
-    marker: Element;
-    nodes: Elements[];
-    text: Element | null;
-    constructor(marker: Element);
-    get length(): number;
-    set length(n: number);
-    anchor(index?: number): Element;
-    clear(): void;
-    pop(): Elements[] | undefined;
-    push(...groups: HydrateResult[]): number;
-    render(input: unknown, state?: number): this;
-    shift(): Elements[] | undefined;
-    splice(start: number, stop?: number, ...groups: HydrateResult[]): Elements[];
-    unshift(...groups: HydrateResult[]): number;
-}
-declare const ondisconnect: (element: Element, fn: VoidFunction) => void;
-declare const _default: (marker: Element, value: unknown) => Slot;
-export default _default;
-export { ondisconnect, Slot };

package/build/slot.js

@@ -1,200 +0,0 @@
-import { effect, root } from '@esportsplus/reactivity';
-import { isArray, isFunction, isInstanceOf, isObject } from '@esportsplus/utilities';
-import { RENDERABLE, RENDERABLE_REACTIVE } from './constants.js';
-import { hydrate } from './html/index.js';
-import { append, cloneNode, firstChild, fragment, microtask, nextSibling, nodeValue, raf, text } from './utilities.js';
-import queue from '@esportsplus/queue';
-const CLEANUP_KEY = Symbol();
-const CONNECTED = 0;
-const HYDRATING = 1;
-let cleanup = queue(64), scheduled = false, template = fragment('');
-function after(anchor, groups) {
-    let n = groups.length;
-    if (n === 0) {
-        return [];
-    }
-    let fragment = cloneNode.call(template), elements = new Array(n);
-    for (let i = 0; i < n; i++) {
-        let { elements: e, fragment: f } = groups[i];
-        append.call(fragment, f);
-        elements[i] = e;
-    }
-    anchor.after(fragment);
-    return elements;
-}
-function remove(groups) {
-    for (let i = 0, n = groups.length; i < n; i++) {
-        let group = groups[i];
-        for (let j = 0, o = group.length; j < o; j++) {
-            let item = group[j];
-            if (CLEANUP_KEY in item) {
-                cleanup.add(item[CLEANUP_KEY]);
-            }
-            item.remove();
-        }
-    }
-    if (!scheduled && cleanup.length) {
-        schedule();
-    }
-    return groups;
-}
-function render(elements, fragment, input, slot) {
-    if (input === false || input == null || input === '') {
-        return;
-    }
-    let type = typeof input;
-    if (type === 'string' || type === 'number') {
-        let element = text(type === 'string' ? input : String(input));
-        if (slot) {
-            slot.text = element;
-        }
-        append.call(fragment, element);
-        elements.push([element]);
-    }
-    else if (isArray(input)) {
-        for (let i = 0, n = input.length; i < n; i++) {
-            render(elements, fragment, input[i]);
-        }
-    }
-    else if (isObject(input) && RENDERABLE in input) {
-        if (input[RENDERABLE] === RENDERABLE_REACTIVE) {
-            let response = hydrate.reactive(input, slot);
-            for (let i = 0, n = response.length; i < n; i++) {
-                let { elements: e, fragment: f } = response[i];
-                append.call(fragment, f);
-                elements.push(e);
-            }
-        }
-        else {
-            let { elements: e, fragment: f } = hydrate.static(input);
-            append.call(fragment, f);
-            elements.push(e);
-        }
-    }
-    else if (isInstanceOf(input, NodeList)) {
-        let e = new Array(input.length), i = 0;
-        for (let node = firstChild.call(input); node; node = nextSibling.call(node)) {
-            e[i++] = node;
-        }
-        append.call(fragment, ...e);
-        elements.push(e);
-    }
-    else if (isInstanceOf(input, Node)) {
-        append.call(fragment, input);
-        elements.push([input]);
-    }
-}
-function schedule() {
-    if (scheduled) {
-        return;
-    }
-    scheduled = true;
-    microtask.add(task);
-}
-function task() {
-    let fn, fns;
-    while (fns = cleanup.next()) {
-        try {
-            while (fn = fns.pop()) {
-                fn();
-            }
-        }
-        catch { }
-    }
-    scheduled = false;
-    if (cleanup.length) {
-        schedule();
-    }
-}
-class Slot {
-    marker;
-    nodes;
-    text = null;
-    constructor(marker) {
-        ondisconnect(marker, () => this.clear());
-        this.marker = marker;
-        this.nodes = [];
-    }
-    get length() {
-        return this.nodes.length;
-    }
-    set length(n) {
-        this.splice(n);
-    }
-    anchor(index = this.nodes.length - 1) {
-        let nodes = this.nodes[index];
-        return nodes ? nodes[nodes.length - 1] : this.marker;
-    }
-    clear() {
-        remove(this.nodes);
-        this.nodes.length = 0;
-        this.text = null;
-    }
-    pop() {
-        let group = this.nodes.pop();
-        if (!group) {
-            return undefined;
-        }
-        return remove([group]);
-    }
-    push(...groups) {
-        return this.nodes.push(...after(this.anchor(), groups));
-    }
-    render(input, state = HYDRATING) {
-        if (isFunction(input)) {
-            ondisconnect(this.marker, effect(() => {
-                let v = input();
-                if (isFunction(v)) {
-                    root(() => this.render(v(), state));
-                    state = CONNECTED;
-                }
-                else if (state === HYDRATING) {
-                    this.render(v, state);
-                    state = CONNECTED;
-                }
-                else if (state === CONNECTED) {
-                    raf.add(() => {
-                        this.render(v, state);
-                    });
-                }
-            }));
-            return this;
-        }
-        if (this.text && this.text.isConnected) {
-            let type = typeof input;
-            if (input == null || type !== 'object') {
-                nodeValue.call(this.text, (type === 'number' || type === 'string') ? input : '');
-                return this;
-            }
-        }
-        this.clear();
-        let fragment = cloneNode.call(template), nodes = [];
-        render(nodes, fragment, input, this);
-        this.marker.after(fragment);
-        this.nodes = nodes;
-        return this;
-    }
-    shift() {
-        let group = this.nodes.shift();
-        if (!group) {
-            return undefined;
-        }
-        return remove([group]);
-    }
-    splice(start, stop = this.nodes.length, ...groups) {
-        if (!groups.length) {
-            return remove(this.nodes.splice(start, stop));
-        }
-        return remove(this.nodes.splice(start, stop, ...after(this.anchor(start), groups)));
-    }
-    unshift(...groups) {
-        return this.nodes.unshift(...after(this.marker, groups));
-    }
-}
-const ondisconnect = (element, fn) => {
-    (element[CLEANUP_KEY] ??= []).push(fn);
-};
-export default (marker, value) => {
-    return new Slot(marker).render(value);
-};
-export { ondisconnect, Slot };