nesquick 0.0.2

package/lib/For/For.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.For = For;
+const State_1 = require("../State");
+const NesquickFragment_1 = require("../NesquickFragment");
+const getMap_1 = require("./getMap");
+function renderChild(child, item, render) {
+    let getI = () => {
+        const iState = (0, State_1.useState)(child.i);
+        getI = iState[0];
+        child.setI = iState[1];
+        return iState[0]();
+    };
+    child.element = render(item, () => getI());
+    return child;
+}
+;
+function getCycleMap(props) {
+    const map = (0, getMap_1.getMap)(props);
+    let cycle = false;
+    return {
+        ...map,
+        cycle() {
+            cycle = !cycle;
+        },
+        pushChild(id, child) {
+            const childs = map.getChild(id);
+            if (childs) {
+                child.childs = childs;
+                childs.list.push(child);
+            }
+            else {
+                map.setChild(id, child.childs = {
+                    list: [child],
+                    offset: 0,
+                    cycle: cycle
+                });
+            }
+        },
+        getChild(id) {
+            const childs = map.getChild(id);
+            if (childs) {
+                if (childs.cycle === cycle) {
+                    if (childs.offset < childs.list.length) {
+                        return childs.list[childs.offset++];
+                    }
+                }
+                else {
+                    childs.cycle = cycle;
+                    childs.offset = 1;
+                    return childs.list[0];
+                }
+            }
+        },
+        popChild(child) {
+            const childs = child.childs;
+            if (childs.list.length === 1) {
+                map.deleteChild(child.id);
+            }
+            else {
+                if (childs.offset === childs.list.length) {
+                    childs.offset--;
+                }
+                childs.list.pop();
+            }
+        },
+        skipChild(child) {
+            const childs = child.childs;
+            if (childs.cycle === cycle) {
+                if (childs.offset < childs.list.length) {
+                    childs.offset++;
+                }
+            }
+            else {
+                childs.offset = 1;
+                childs.cycle = cycle;
+            }
+        }
+    };
+}
+function For(props) {
+    const children = [];
+    const fragment = new NesquickFragment_1.NesquickFragment([]);
+    let cycle = false;
+    const map = getCycleMap(props);
+    (0, State_1.useRender)(() => {
+        cycle = !cycle;
+        const each = props.each().slice();
+        if (children.length === 0) {
+            for (let i = 0; i < each.length; i++) {
+                const item = each[i];
+                const id = map.getId(item, i);
+                const child = renderChild({
+                    id: id,
+                    i: i,
+                    setI: null,
+                    element: null,
+                    cycle: cycle,
+                    childs: null
+                }, item, props.children);
+                map.pushChild(id, child);
+                children.push(child);
+                fragment.appendElement(child.element);
+            }
+        }
+        else if (each.length === 0) {
+            for (let i = 0; i < children.length; i++) {
+                fragment.removeElement(i);
+            }
+            map.clearChilds();
+            children.splice(0);
+        }
+        else {
+            map.cycle();
+            for (let i = 0; i < each.length; i++) {
+                const item = each[i];
+                const id = map.getId(item, i);
+                const child = map.getChild(id);
+                if (child) {
+                    child.cycle = cycle;
+                }
+            }
+            map.cycle();
+            let min = Math.min(children.length, each.length);
+            let offset = 0;
+            for (let i = 0; i < min; i++) {
+                const item = each[i];
+                const id = map.getId(item, i);
+                const oldChild = children[i];
+                if (!map.equalsId(oldChild.id, id)) {
+                    if (oldChild.cycle !== cycle) {
+                        fragment.removeElement(i);
+                        children.splice(i--, 1);
+                        map.popChild(oldChild);
+                        if (children.length < each.length) {
+                            min = children.length;
+                        }
+                        offset--;
+                        continue;
+                    }
+                    else {
+                        let child = map.getChild(id);
+                        if (!child) {
+                            child = renderChild({
+                                id: id,
+                                i: i,
+                                setI: null,
+                                element: null,
+                                cycle: cycle,
+                                childs: null
+                            }, item, props.children);
+                            fragment.spliceElement(i, child.element);
+                            map.pushChild(id, child);
+                            children.splice(i, 0, child);
+                            if (children.length <= each.length) {
+                                min = children.length;
+                            }
+                            offset++;
+                        }
+                        else {
+                            children[child.i + offset] = oldChild;
+                            children[i] = child;
+                            oldChild.i = child.i;
+                            child.i = i;
+                            child.setI?.(i);
+                            fragment.swapElements(oldChild.i + offset, child.i);
+                        }
+                    }
+                }
+                else {
+                    map.skipChild(oldChild);
+                    if (oldChild.i !== i) {
+                        oldChild.i = i;
+                        oldChild.setI?.(i);
+                    }
+                }
+            }
+            for (let i = min; i < each.length; i++) {
+                const item = each[i];
+                const id = map.getId(item, i);
+                const child = renderChild({
+                    id: id,
+                    i: i,
+                    setI: null,
+                    element: null,
+                    cycle: cycle,
+                    childs: null
+                }, item, props.children);
+                map.pushChild(id, child);
+                children.push(child);
+                fragment.appendElement(child.element);
+            }
+            if (each.length < children.length) {
+                for (let i = children.length - 1; i >= each.length; i--) {
+                    const oldChild = children[i];
+                    fragment.removeElement(i);
+                    map.popChild(oldChild);
+                }
+                children.splice(each.length);
+            }
+        }
+    });
+    return fragment;
+}

package/lib/For/getMap.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMap = getMap;
+function getMap(props) {
+    if ("ids" in props && props.ids) {
+        const childrenMap = new Map();
+        let idLength = 0;
+        return {
+            getId(item, i) {
+                const ids = props.ids(item, i);
+                if (!ids || ids.length === 0) {
+                    throw new Error(`Invalid ids array length. ids() should not return an empty array`);
+                }
+                if (idLength === 0) {
+                    idLength = ids.length;
+                }
+                else if (ids.length !== idLength) {
+                    throw new Error(`Invalid ids array length. Expected: ${idLength}. Found: ${ids.length}. Make sure ids() always return the same length`);
+                }
+                return ids;
+            },
+            equalsId(a, b) {
+                for (let i = 0; i < a.length; i++) {
+                    if (a[i] !== b[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            },
+            getChild(ids) {
+                let map = childrenMap;
+                for (let i = 0; i < ids.length; i++) {
+                    map = map.get(ids[i]);
+                    if (!map) {
+                        break;
+                    }
+                }
+                return map;
+            },
+            setChild(ids, child) {
+                let map = childrenMap;
+                for (let i = 0; i < ids.length - 1; i++) {
+                    const childMap = map.get(ids[i]);
+                    if (!childMap) {
+                        map.set(ids[i], map = new Map());
+                    }
+                    else {
+                        map = childMap;
+                    }
+                }
+                map.set(ids[ids.length - 1], child);
+            },
+            deleteChild(ids) {
+                let parentMap = null;
+                let map = childrenMap;
+                for (let i = 0; i < ids.length - 1; i++) {
+                    parentMap = map;
+                    map = parentMap.get(ids[i]);
+                    if (!map) {
+                        return;
+                    }
+                }
+                for (let i = ids.length - 1; i >= 0; i--) {
+                    map.delete(ids[i]);
+                    if (map.size === 0) {
+                        map = parentMap;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            },
+            clearChilds() {
+                childrenMap.clear();
+            }
+        };
+    }
+    else {
+        const childrenMap = new Map();
+        return {
+            getId: ("id" in props && props.id) || (item => item),
+            equalsId(a, b) {
+                return a === b;
+            },
+            getChild(id) {
+                return childrenMap.get(id);
+            },
+            setChild(id, child) {
+                childrenMap.set(id, child);
+            },
+            deleteChild(id) {
+                childrenMap.delete(id);
+            },
+            clearChilds() {
+                childrenMap.clear();
+            }
+        };
+    }
+}
+;

package/lib/Nesquick.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nesquick = void 0;
+var Nesquick;
+(function (Nesquick) {
+    function render(element, parent) {
+        if (parent != null) {
+            parent.appendChild(element.render(parent.ownerDocument));
+        }
+        else {
+            document.body.appendChild(element.render(document));
+        }
+    }
+    Nesquick.render = render;
+})(Nesquick || (exports.Nesquick = Nesquick = {}));
+exports.default = Nesquick;

package/lib/NesquickElement.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesquickElement = void 0;
+const State_1 = require("./State");
+function functionizeProps(props) {
+    for (const k in props) {
+        if (typeof props[k] !== "function") {
+            const v = props[k];
+            props[k] = () => v;
+        }
+    }
+}
+class NesquickElement {
+    constructor(_render, props) {
+        this._render = _render;
+        this.props = props;
+        this._subscriptions = new State_1.Subscriptions();
+        this._children = [];
+        this.props = props;
+    }
+    render(document) {
+        State_1.subscriptions.set(this._subscriptions);
+        if (typeof this._render === "function") {
+            functionizeProps(this.props);
+            const res = this._render(this.props).render(document);
+            State_1.subscriptions.reset();
+            return res;
+        }
+        const element = document.createElement(this._render);
+        if (this.props != null) {
+            this._renderProps(element, this.props);
+        }
+        this._renderChildren(document, element, this.props.children);
+        this.props = {};
+        State_1.subscriptions.reset();
+        return element;
+    }
+    _renderProps(element, props) {
+        for (const k in props) {
+            if (k !== "children") {
+                if (typeof props[k] === "function") {
+                    (0, State_1.useRender)(props[k], v => {
+                        element.setAttribute(k, String(v));
+                    });
+                }
+                else {
+                    element.setAttribute(k, String(props[k]));
+                }
+            }
+        }
+    }
+    _renderChildren(document, parent, children) {
+        if (children != null) {
+            if (!Array.isArray(children)) {
+                children = [children];
+            }
+            for (const child of children) {
+                if (child instanceof NesquickElement) {
+                    this._renderChild(document, parent, this._pushChild(), child);
+                }
+                else if (typeof child === "function") {
+                    const ch = this._pushChild();
+                    (0, State_1.useRender)(child, children => {
+                        this._renderChild(document, parent, ch, children);
+                    });
+                }
+                else {
+                    this._renderChild(document, parent, this._pushChild(), child);
+                }
+            }
+        }
+    }
+    _pushChild() {
+        const nesquickChild = {
+            node: null,
+            element: null,
+            fragment: null
+        };
+        this._children.push(nesquickChild);
+        return nesquickChild;
+    }
+    _spliceChild(i) {
+        const nesquickChild = {
+            node: null,
+            element: null,
+            fragment: null
+        };
+        this._children.splice(i, 0, nesquickChild);
+        return nesquickChild;
+    }
+    _swapChilds(parent, i1, i2) {
+        const ch1 = this._children[i1];
+        const ch2 = this._children[i2];
+        if (ch1 && ch2) {
+            this._children[i1] = ch2;
+            this._children[i2] = ch1;
+            if (ch1.node && ch2.node) {
+                const node2Sibling = ch2.node.nextSibling;
+                if (node2Sibling === ch1.node) {
+                    parent.insertBefore(ch1.node, ch2.node);
+                }
+                else {
+                    parent.insertBefore(ch2.node, ch1.node);
+                    parent.insertBefore(ch1.node, node2Sibling);
+                }
+            }
+        }
+    }
+    _removeChild(i) {
+        const ch = this._children[i];
+        if (ch) {
+            this._children.splice(i, 1);
+            if (ch.node) {
+                ch.node.parentNode?.removeChild(ch.node);
+            }
+            if (ch.element != null) {
+                ch.element.dispose();
+            }
+            else if (ch.fragment != null) {
+                ch.fragment.dispose();
+            }
+        }
+    }
+    _renderChild(document, parent, nesquickChild, child) {
+        if (nesquickChild.element != null) {
+            nesquickChild.element.dispose();
+        }
+        else if (nesquickChild.fragment != null) {
+            nesquickChild.fragment.clear();
+        }
+        if (child instanceof NesquickFragment_1.NesquickFragment || Array.isArray(child)) {
+            nesquickChild.element = null;
+            nesquickChild.fragment = Array.isArray(child) ? new NesquickFragment_1.NesquickFragment(child) : child;
+            const node = nesquickChild.fragment.render(document);
+            const lastChild = node.lastChild;
+            if (nesquickChild.node) {
+                parent.replaceChild(node, nesquickChild.node);
+            }
+            else {
+                parent.appendChild(node);
+            }
+            nesquickChild.node = lastChild;
+        }
+        else if (child instanceof NesquickElement) {
+            nesquickChild.element = child;
+            nesquickChild.fragment = null;
+            const node = child.render(document);
+            if (nesquickChild.node) {
+                parent.replaceChild(node, nesquickChild.node);
+            }
+            else {
+                parent.appendChild(node);
+            }
+            nesquickChild.node = node;
+        }
+        else {
+            const value = child == null ? "" : String(child);
+            if (nesquickChild.node == null || nesquickChild.element != null || nesquickChild.fragment != null) {
+                nesquickChild.element = null;
+                nesquickChild.fragment = null;
+                const node = document.createTextNode(value);
+                if (nesquickChild.node) {
+                    parent.replaceChild(node, nesquickChild.node);
+                }
+                else {
+                    parent.appendChild(node);
+                }
+                nesquickChild.node = node;
+            }
+            else {
+                nesquickChild.node.textContent = value;
+            }
+        }
+    }
+    dispose() {
+        this._subscriptions.dispose();
+        for (const child of this._children) {
+            if (child.element) {
+                child.element.dispose();
+            }
+        }
+    }
+}
+exports.NesquickElement = NesquickElement;
+const NesquickFragment_1 = require("./NesquickFragment");

package/lib/NesquickFragment.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesquickFragment = void 0;
+const NesquickElement_1 = require("./NesquickElement");
+class NesquickFragment extends NesquickElement_1.NesquickElement {
+    constructor(children) {
+        super("", { children });
+        this._lastNode = null;
+        this._fragment = null;
+    }
+    render(document) {
+        this._fragment = document.createDocumentFragment();
+        this._renderChildren(document, this, this.props.children);
+        this.props = {};
+        this._lastNode = document.createComment("Fragment");
+        this._fragment.appendChild(this._lastNode);
+        return this._fragment;
+    }
+    getDocument() {
+        return (this._lastNode?.ownerDocument || this._fragment?.ownerDocument) || null;
+    }
+    getParent() {
+        return this._lastNode?.parentNode || this._fragment;
+    }
+    appendChild(child) {
+        const parent = this.getParent();
+        if (parent) {
+            parent.insertBefore(child, this._lastNode);
+        }
+    }
+    replaceChild(newChild, oldChild) {
+        const parent = this.getParent();
+        if (parent) {
+            parent.replaceChild(newChild, oldChild);
+        }
+    }
+    insertBefore(node, child) {
+        const parent = this.getParent();
+        if (parent) {
+            parent.insertBefore(node, child || this._lastNode);
+        }
+    }
+    appendElement(child) {
+        const document = this.getDocument();
+        const parent = this.getParent();
+        if (document && parent) {
+            const ch = this._pushChild();
+            this._renderChild(document, this, ch, child);
+        }
+        else {
+            this.props.children.push(child);
+        }
+    }
+    swapElements(i1, i2) {
+        const parent = this.getParent();
+        if (parent) {
+            this._swapChilds(parent, i1, i2);
+        }
+    }
+    removeElement(i) {
+        this._removeChild(i);
+    }
+    spliceElement(i, child) {
+        const document = this.getDocument();
+        const parent = this.getParent();
+        if (document && parent) {
+            const spliced = this._children[i];
+            const ch = this._spliceChild(i);
+            ch.node = document.createComment("");
+            if (spliced?.node) {
+                parent.insertBefore(ch.node, spliced.node);
+            }
+            this._renderChild(document, this, ch, child);
+        }
+        else {
+            this.props.children.splice(i, 0, child);
+        }
+    }
+    clear() {
+        const parent = this._lastNode?.parentNode || this._fragment;
+        if (parent) {
+            for (const child of this._children) {
+                if (child.node) {
+                    parent.removeChild(child.node);
+                }
+            }
+        }
+        this.dispose();
+    }
+}
+exports.NesquickFragment = NesquickFragment;

package/lib/State.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptions = exports.Subscriptions = void 0;
+exports.useState = useState;
+exports.useEffect = useEffect;
+exports.useRender = useRender;
+exports.useDispose = useDispose;
+let currentReactor = [];
+var reactor;
+(function (reactor_1) {
+    function set(reactor) {
+        currentReactor.push(reactor);
+    }
+    reactor_1.set = set;
+    function reset() {
+        currentReactor.pop();
+    }
+    reactor_1.reset = reset;
+})(reactor || (reactor = {}));
+let pendingReactor = null;
+function renderReactor(reactor, instant) {
+    if (instant) {
+        runSubscription(reactor);
+    }
+    else if (!reactor.pending) {
+        reactor.pending = true;
+        if (pendingReactor == null) {
+            pendingReactor = {
+                first: reactor,
+                last: reactor
+            };
+            requestAnimationFrame(renderReactors);
+        }
+        else {
+            pendingReactor.last.next = reactor;
+            pendingReactor.last = reactor;
+        }
+    }
+}
+function renderReactors() {
+    let next = pendingReactor.first;
+    do {
+        if (!next.cancelled) {
+            runSubscription(next);
+        }
+        const n = next.next;
+        next.next = null;
+        next = n;
+    } while (next);
+    pendingReactor = null;
+}
+class Subscriptions {
+    constructor() {
+        this.list = [];
+        this.onDispose = [];
+    }
+    dispose() {
+        for (const sub of this.list) {
+            cancelSubscription(sub);
+        }
+        for (const cb of this.onDispose) {
+            cb();
+        }
+    }
+}
+exports.Subscriptions = Subscriptions;
+let currentSubscriptions = [];
+var subscriptions;
+(function (subscriptions) {
+    function set(container) {
+        currentSubscriptions.push(container);
+    }
+    subscriptions.set = set;
+    function reset() {
+        currentSubscriptions.pop();
+    }
+    subscriptions.reset = reset;
+})(subscriptions || (exports.subscriptions = subscriptions = {}));
+function useState(value) {
+    const reactors = new Set();
+    const getValue = () => {
+        const reactor = currentReactor[currentReactor.length - 1];
+        if (reactor) {
+            reactors.add(reactor);
+            reactor.states.set(reactors, reactor.iteration);
+        }
+        return value;
+    };
+    const setValue = (newValue) => {
+        value = newValue;
+        for (const reactor of reactors) {
+            renderReactor(reactor, reactor.effect);
+        }
+    };
+    return [getValue, setValue];
+}
+function useEffect(cb, reaction = null) {
+    newSubscription(cb, reaction, true);
+}
+function useRender(cb, reaction = null) {
+    newSubscription(cb, reaction, false);
+}
+function useDispose(cb) {
+    const container = currentSubscriptions[currentSubscriptions.length - 1];
+    if (container) {
+        container.onDispose.push(cb);
+    }
+}
+function newSubscription(cb, reaction, effect) {
+    const sub = {
+        cb: cb,
+        reaction: reaction,
+        iteration: 0,
+        states: new Map(),
+        next: null,
+        effect: effect,
+        cancelled: false,
+        pending: false
+    };
+    renderReactor(sub, true);
+    if (sub.states.size === 0) {
+        cancelSubscription(sub);
+    }
+    else {
+        const container = currentSubscriptions[currentSubscriptions.length - 1];
+        if (container) {
+            container.list.push(sub);
+        }
+    }
+}
+function cancelSubscription(sub) {
+    sub.cancelled = true;
+    for (const reactors of sub.states.keys()) {
+        reactors.delete(sub);
+    }
+}
+function runSubscription(sub) {
+    sub.pending = false;
+    reactor.set(sub);
+    const res = sub.cb();
+    reactor.reset();
+    for (const [state, iteration] of sub.states) {
+        if (iteration !== sub.iteration) {
+            sub.states.delete(state);
+        }
+    }
+    sub.reaction?.(res);
+}

package/lib/cli/transformer.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = void 0;
+const TS = require("typescript");
+function getSingleIdentifier(node) {
+    const identifiers = [];
+    node.forEachChild(node => {
+        if (TS.isIdentifier(node)) {
+            identifiers.push(node);
+        }
+    });
+    if (identifiers.length === 1) {
+        return identifiers[0];
+    }
+    return null;
+}
+function getSingleBody(node) {
+    const body = [];
+    node.forEachChild(node => {
+        body.push(node);
+    });
+    if (body.length === 1) {
+        return body[0];
+    }
+    return null;
+}
+function hasIdentifier(node) {
+    let found = false;
+    node.forEachChild(node => {
+        if (!found && (TS.isIdentifier(node) || hasIdentifier(node))) {
+            found = true;
+        }
+    });
+    return found;
+}
+const transformer = context => {
+    return sourceFile => {
+        const visitorGeneric = node => {
+            if (TS.isJsxAttribute(node)) {
+                return TS.visitEachChild(node, visitorAttribute, context);
+            }
+            return TS.visitEachChild(node, visitorGeneric, context);
+        };
+        const visitorAttribute = node => {
+            if (TS.isJsxExpression(node)) {
+                return TS.visitEachChild(node, visitorExpression, context);
+            }
+            return TS.visitEachChild(node, visitorGeneric, context);
+        };
+        const visitorExpression = node => {
+            if (TS.isParenthesizedExpression(node)) {
+                const body = getSingleBody(node);
+                if (body) {
+                    return TS.visitNode(body, visitorExpression, TS.isSourceFile);
+                }
+            }
+            else if (TS.isCallExpression(node)) {
+                const identifier = getSingleIdentifier(node);
+                if (identifier) {
+                    return identifier;
+                }
+                else {
+                    return TS.factory.createArrowFunction(undefined, undefined, [], undefined, TS.factory.createToken(TS.SyntaxKind.EqualsGreaterThanToken), node);
+                }
+            }
+            else if (TS.isExpression(node) && hasIdentifier(node)) {
+                return TS.factory.createArrowFunction(undefined, undefined, [], undefined, TS.factory.createToken(TS.SyntaxKind.EqualsGreaterThanToken), node);
+            }
+            return node;
+        };
+        return TS.visitNode(sourceFile, visitorGeneric, TS.isSourceFile);
+    };
+};
+exports.transformer = transformer;

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Nesquick"), exports);
+__exportStar(require("./For/For"), exports);
+__exportStar(require("./cli/transformer"), exports);

package/lib/jsx-runtime.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSX = exports.jsx = exports.Fragment = void 0;
+exports.jsxs = jsxs;
+const NesquickElement_1 = require("./NesquickElement");
+const NesquickFragment_1 = require("./NesquickFragment");
+exports.Fragment = Symbol();
+function jsxs(type, props, key) {
+    if (type === exports.Fragment) {
+        return new NesquickFragment_1.NesquickFragment(props.children);
+    }
+    if (key !== undefined) {
+        props.key = key;
+    }
+    return new NesquickElement_1.NesquickElement(type, props);
+}
+exports.jsx = jsxs;
+var JSX;
+(function (JSX) {
+})(JSX || (exports.JSX = JSX = {}));

package/lib/types/For/For.d.ts

@@ -0,0 +1,18 @@
+import { Props, JSX } from "../jsx-runtime";
+import { NesquickFragment } from "../NesquickFragment";
+type ChildRender<T> = (item: T, i: () => number) => JSX.Element;
+export type ForProps<T> = {
+    each: T[];
+    children: ChildRender<T>;
+} & ({
+    ids?: never;
+    id: (item: T, i: number) => unknown;
+} | {
+    ids: (item: T, i: number) => unknown[];
+    id?: never;
+} | {
+    ids?: never;
+    id?: never;
+});
+export declare function For<T>(props: Props<ForProps<T>>): NesquickFragment;
+export {};

package/lib/types/For/getMap.d.ts

@@ -0,0 +1,23 @@
+import { Props } from "../jsx-runtime";
+import { ForProps } from "./For";
+export type IdMap<T, ID, CHILD> = {
+    getId(item: T, i: number): ID;
+    equalsId(a: ID, b: ID): boolean;
+    getChild(id: ID): CHILD | undefined;
+    setChild(id: ID, child: CHILD): void;
+    deleteChild(id: ID): void;
+    clearChilds(): void;
+};
+type IdMapProps<T> = Props<Pick<Extract<ForProps<T>, {
+    id?: unknown;
+}>, "id"> | Pick<Extract<ForProps<T>, {
+    ids?: unknown;
+}>, "ids">>;
+export declare function getMap<T, CHILD>(props: Required<Extract<IdMapProps<T>, {
+    id?: unknown;
+}>>): IdMap<T, unknown, CHILD>;
+export declare function getMap<T, CHILD>(props: Required<Extract<IdMapProps<T>, {
+    ids?: unknown;
+}>>): IdMap<T, unknown[], CHILD>;
+export declare function getMap<T, CHILD>(props: IdMapProps<T>): IdMap<T, T, CHILD>;
+export {};

package/lib/types/Nesquick.d.ts

@@ -0,0 +1,6 @@
+import { NesquickElement, Children, Child } from "./NesquickElement";
+export declare namespace Nesquick {
+    function render(element: NesquickElement<any>, parent?: HTMLElement | null): void;
+}
+export { Children, Child };
+export default Nesquick;

package/lib/types/NesquickElement.d.ts

@@ -0,0 +1,37 @@
+export type Child = NesquickElement<any> | NesquickFragment | string | boolean | number | null | undefined | ChildFunc;
+export type Children = Child | Child[];
+export type ChildFunc = () => Exclude<Child, ChildFunc> | Exclude<Child, ChildFunc>[];
+export type Props = Record<string, any>;
+export type FunctionComponent<P extends Props = {}> = (props: P) => NesquickElement<P>;
+type NesquickChild = {
+    node: Node | null;
+} & ({
+    element: NesquickElement | null;
+    fragment: null;
+} | {
+    element: null;
+    fragment: NesquickFragment | null;
+});
+export type NesquickParent = {
+    appendChild(child: Node): void;
+    replaceChild(newChild: Node, oldChild: Node): void;
+    insertBefore(node: Node, child: Node | null): void;
+};
+export declare class NesquickElement<P extends Props = {}> {
+    private _render;
+    protected props: P;
+    private _subscriptions;
+    protected _children: NesquickChild[];
+    constructor(_render: string | FunctionComponent<P>, props: P);
+    render(document: Document): Node;
+    private _renderProps;
+    protected _renderChildren(document: Document, parent: NesquickParent, children?: Children): void;
+    protected _pushChild(): NesquickChild;
+    protected _spliceChild(i: number): NesquickChild;
+    protected _swapChilds(parent: NesquickParent, i1: number, i2: number): void;
+    protected _removeChild(i: number): void;
+    protected _renderChild(document: Document, parent: NesquickParent, nesquickChild: NesquickChild, child: Exclude<Child, ChildFunc> | Exclude<Child, ChildFunc>[]): void;
+    dispose(): void;
+}
+import { NesquickFragment } from "./NesquickFragment";
+export {};

package/lib/types/NesquickFragment.d.ts

@@ -0,0 +1,20 @@
+import { JSX } from "./jsx-runtime";
+import { NesquickElement, NesquickParent } from "./NesquickElement";
+export declare class NesquickFragment extends NesquickElement<{
+    children: any[];
+}> implements NesquickParent {
+    private _lastNode;
+    private _fragment;
+    constructor(children: any[]);
+    render(document: Document): Node;
+    getDocument(): Document | null;
+    getParent(): Node | null;
+    appendChild(child: Node): void;
+    replaceChild(newChild: Node, oldChild: Node): void;
+    insertBefore(node: Node, child: Node | null): void;
+    appendElement(child: JSX.Element): void;
+    swapElements(i1: number, i2: number): void;
+    removeElement(i: number): void;
+    spliceElement(i: number, child: JSX.Element): void;
+    clear(): void;
+}

package/lib/types/State.d.ts

@@ -0,0 +1,24 @@
+export type State<T> = [get: () => T, set: (value: T) => void];
+export type Subscription<T> = {
+    cb: () => T;
+    reaction: ((data: T) => void) | null;
+    iteration: number;
+    states: Map<Set<Subscription<any>>, number>;
+    next: Subscription<T> | null;
+    effect: boolean;
+    cancelled: boolean;
+    pending: boolean;
+};
+export declare class Subscriptions {
+    list: Subscription<any>[];
+    onDispose: (() => void)[];
+    dispose(): void;
+}
+export declare namespace subscriptions {
+    function set(container: Subscriptions): void;
+    function reset(): void;
+}
+export declare function useState<T>(value: T): State<T>;
+export declare function useEffect<T>(cb: () => T, reaction?: ((data: T) => void) | null): void;
+export declare function useRender<T>(cb: () => T, reaction?: ((data: T) => void) | null): void;
+export declare function useDispose(cb: () => void): void;

package/lib/types/cli/transformer.d.ts

@@ -0,0 +1,2 @@
+import * as TS from "typescript";
+export declare const transformer: TS.TransformerFactory<TS.SourceFile>;

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Nesquick";
+export * from "./For/For";
+export * from "./cli/transformer";

package/lib/types/jsx-runtime.d.ts

@@ -0,0 +1,66 @@
+import { FunctionComponent, Props, NesquickElement } from "./NesquickElement";
+import { NesquickFragment } from "./NesquickFragment";
+export declare const Fragment: unique symbol;
+export declare function jsxs<P extends Props>(type: string | FunctionComponent<P> | typeof Fragment, props: P, key?: string): NesquickFragment | NesquickElement<P>;
+export declare const jsx: typeof jsxs;
+declare const WrappedFunctionType: unique symbol;
+type WrappedFunction<T> = (() => T) & {
+    readonly [WrappedFunctionType]?: T;
+};
+type UserProp<T> = T extends (...args: infer A) => infer R ? (((...args: A) => R) | T) : WrappedFunction<T>;
+type ComponentProp<T> = T extends {
+    readonly [WrappedFunctionType]?: infer R;
+} ? (T | R) : T extends (...args: any[]) => any ? T : (T | (() => T));
+type UnFunction<T> = T extends {
+    readonly [WrappedFunctionType]?: infer R;
+} ? (T | R) : T;
+type UserProps<T> = {
+    [K in keyof T]: K extends "children" ? T[K] : UserProp<T[K]>;
+};
+type ComponentProps<T> = keyof T extends never ? {} : {
+    [K in keyof T]: K extends "children" ? UnFunction<T[K]> : ComponentProp<T[K]>;
+};
+export type Generic<T> = T extends (...args: any) => infer R ? R : T;
+export { UserProps as Props };
+export type Component<P = {}> = (props: UserProps<P>) => JSX.Element;
+export declare namespace JSX {
+    export type JSXEvent<T extends Event, T2 extends EventTarget> = T & {
+        currentTarget: T2;
+    };
+    export type JSXHTMLEvent<T extends EventTarget> = {
+        [K in keyof HTMLElementEventMap as `on${Capitalize<K>}`]?: (e: JSXEvent<HTMLElementEventMap[K], T>) => void;
+    };
+    export type JSXSVGEvent<T extends EventTarget> = {
+        [K in keyof SVGElementEventMap as `on${Capitalize<K>}`]?: (e: JSXEvent<SVGElementEventMap[K], T>) => void;
+    };
+    export interface Props<T extends EventTarget = HTMLElement> extends JSXHTMLEvent<T> {
+        [k: string]: any;
+        style?: StyleProps;
+    }
+    export type StyleProps = {
+        [K in keyof CSSStyleDeclaration]?: CSSStyleDeclaration[K] extends Function ? never : CSSStyleDeclaration[K] | (() => CSSStyleDeclaration[K]);
+    };
+    export type HTMLProps<T extends HTMLElement = HTMLElement> = Props<T>;
+    export type SVGProps<T extends SVGElement = SVGElement> = Props<T>;
+    export type JSXElements = {
+        [K in keyof HTMLElementTagNameMap]: HTMLProps<HTMLElementTagNameMap[K]>;
+    } & {
+        [K in keyof SVGElementTagNameMap]: SVGProps<SVGElementTagNameMap[K]>;
+    };
+    export type Element = NesquickElement<any>;
+    export interface IntrinsicElements extends JSXElements {
+    }
+    export type ElementType = keyof IntrinsicElements | Component<any> | typeof NesquickElement<any>;
+    const NotEmptyObject: unique symbol;
+    export type IntrinsicAttributes = {
+        [NotEmptyObject]?: typeof NotEmptyObject;
+    };
+    export interface ElementAttributesProperty {
+        props: {};
+    }
+    export interface ElementChildrenAttribute {
+        children: {};
+    }
+    export type LibraryManagedAttributes<_, P> = ComponentProps<P>;
+    export {};
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "nesquick",
+  "version": "0.0.2",
+  "description": "React-like library with focus on drawing performance",
+  "types": "./lib/types",
+  "main": "./lib",
+  "typesVersions": {
+    "*": {
+      "jsx-runtime": ["./lib/types/jsx-runtime.d.ts"]
+    }
+  },
+  "bin": {
+    "nesquick-tsc": "lib/cli/nesquick-tsc.js",
+    "ntsc": "lib/cli/nesquick-tsc.js"
+  },
+  "sideEffects": false,
+  "files": [
+    "lib/",
+    "LICENSE"
+  ],
+  "private": false,
+  "scripts": {
+    "watch": "npm run clean && npx tsc -p tsconfig.json -watch",
+    "build": "npm run clean && npx tsc -p tsconfig.build.json",
+    "build-debug": "npm run clean && npx tsc -p tsconfig.json",
+    "test": "npx aaa",
+    "clean": "node -e \"require('fs').rm('lib', {recursive: true, force:true}, O_o => {})\""
+  },
+  "author": "Llorx",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Llorx/nesquick.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Llorx/nesquick/issues"
+  },
+  "homepage": "https://github.com/Llorx/nesquick#readme",
+  "devDependencies": {
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^22.7.8",
+    "arrange-act-assert": "^2.9.3",
+    "jsdom": "^26.1.0",
+    "typescript": "^5.6.3"
+  }
+}