nesquick 0.0.25 → 0.0.27

package/lib/NesquickFragment.js

@@ -4,7 +4,9 @@ exports.NesquickFragment = void 0;
 const NesquickComponent_1 = require("./NesquickComponent");
 class NesquickFragment extends NesquickComponent_1.NesquickComponent {
     constructor(children) {
-        super("", { children });
+        super("", {
+            children: children != null ? Array.isArray(children) ? children : [children] : []
+        });
         this._lastNode = null;
         this._fragment = null;
     }

package/lib/cli/transformer.js

@@ -24,60 +24,121 @@ function getSingleBody(node) {
     }
     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 visitGeneric = (node, options) => {
+            let hasSpread = options.userComponent && TS.isJsxSpreadAttribute(node);
+            let hasChildIdentifier = false;
             if (TS.isJsxOpeningLikeElement(node)) {
                 const firstLetter = node.tagName.getText()[0];
                 const userComponent = firstLetter !== firstLetter.toLowerCase();
-                return TS.visitEachChild(node, node => visitGeneric(node, { userComponent }), context);
+                node = TS.visitEachChild(node, node => {
+                    const res = visitGeneric(node, { userComponent });
+                    hasSpread = hasSpread || res.hasSpread;
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                    return res.node;
+                }, context);
+                if (userComponent && hasSpread) {
+                    const symbol = TS.factory.createCallExpression(TS.factory.createPropertyAccessExpression(TS.factory.createIdentifier("Symbol"), "for"), void 0, [TS.factory.createStringLiteral("$nesquickSpreadProps")]);
+                    if (TS.isJsxOpeningLikeElement(node)) {
+                        const attributes = TS.factory.updateJsxAttributes(node.attributes, [
+                            ...node.attributes.properties,
+                            TS.factory.createJsxSpreadAttribute(TS.factory.createObjectLiteralExpression([
+                                TS.factory.createPropertyAssignment(TS.factory.createComputedPropertyName(symbol), TS.factory.createTrue())
+                            ]))
+                        ]);
+                        if (TS.isJsxOpeningElement(node)) {
+                            node = TS.factory.updateJsxOpeningElement(node, node.tagName, node.typeArguments, attributes);
+                        }
+                        else if (TS.isJsxSelfClosingElement(node)) {
+                            node = TS.factory.updateJsxSelfClosingElement(node, node.tagName, node.typeArguments, attributes);
+                        }
+                    }
+                }
             }
-            if (TS.isJsxAttribute(node)) {
-                return TS.visitEachChild(node, node => visitGeneric(node, { ...options, isJsxAttribute: true }), context);
+            else if (TS.isJsxAttribute(node)) {
+                node = TS.visitEachChild(node, node => {
+                    const res = visitGeneric(node, { ...options, isJsxAttribute: true });
+                    hasSpread = hasSpread || res.hasSpread;
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                    return res.node;
+                }, context);
             }
             else if (TS.isJsxExpression(node)) {
-                return TS.visitEachChild(node, node => visitorExpression(node, { ...options, isJsxAttribute: false }), context);
+                node = TS.visitEachChild(node, node => {
+                    const res = visitorExpression(node, { ...options, isJsxAttribute: false });
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                    return res.node;
+                }, context);
             }
             else if (options.isJsxAttribute && TS.isStringLiteral(node)) {
-                const returnNode = TS.visitNode(node, node => visitorExpression(node, { ...options, isJsxAttribute: false }), TS.isExpression);
-                if (!TS.isStringLiteral(returnNode)) {
-                    return TS.factory.createJsxExpression(undefined, returnNode);
+                const returnNode = TS.visitNode(node, node => {
+                    const res = visitorExpression(node, { ...options, isJsxAttribute: false });
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                    return res.node;
+                }, TS.isExpression);
+                if (TS.isStringLiteral(returnNode)) {
+                    node = returnNode;
                 }
-                return returnNode;
+                else {
+                    node = TS.factory.createJsxExpression(undefined, returnNode);
+                }
+            }
+            else {
+                node = TS.visitEachChild(node, node => {
+                    const res = visitGeneric(node, { ...options, isJsxAttribute: false });
+                    hasSpread = hasSpread || res.hasSpread;
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                    return res.node;
+                }, context);
             }
-            return TS.visitEachChild(node, node => visitGeneric(node, { ...options, isJsxAttribute: false }), context);
+            return { hasSpread, hasChildIdentifier, node };
         };
         const visitorExpression = (node, options) => {
+            let hasChildIdentifier = false;
             if (TS.isParenthesizedExpression(node)) {
                 const body = getSingleBody(node);
                 if (body) {
-                    return TS.visitNode(body, node => visitorExpression(node, options));
+                    node = TS.visitNode(body, node => {
+                        const res = visitorExpression(node, options);
+                        hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                        return res.node;
+                    });
                 }
             }
             else if (TS.isCallExpression(node)) {
                 const identifier = getSingleIdentifier(node);
                 if (identifier) {
-                    return identifier;
+                    node = identifier;
                 }
                 else {
-                    return TS.factory.createArrowFunction(undefined, undefined, [], undefined, TS.factory.createToken(TS.SyntaxKind.EqualsGreaterThanToken), TS.visitNode(node, node => visitGeneric(node, {}), TS.isConciseBody));
+                    node = TS.factory.createArrowFunction(undefined, undefined, [], undefined, TS.factory.createToken(TS.SyntaxKind.EqualsGreaterThanToken), TS.visitNode(node, node => {
+                        const res = visitGeneric(node, {});
+                        hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                        return res.node;
+                    }, TS.isConciseBody));
+                }
+            }
+            else if (!TS.isFunctionLike(node) && TS.isExpression(node)) {
+                node = TS.visitNode(node, node => {
+                    const res = visitGeneric(node, {});
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier;
+                    return res.node;
+                });
+                if ((options.userComponent || hasChildIdentifier) && TS.isConciseBody(node)) {
+                    node = TS.factory.createArrowFunction(undefined, undefined, [], undefined, TS.factory.createToken(TS.SyntaxKind.EqualsGreaterThanToken), node);
                 }
             }
-            else if (!TS.isFunctionLike(node) && TS.isExpression(node) && (options.userComponent || hasIdentifier(node))) {
-                return TS.factory.createArrowFunction(undefined, undefined, [], undefined, TS.factory.createToken(TS.SyntaxKind.EqualsGreaterThanToken), TS.visitNode(node, node => visitGeneric(node, {}), TS.isConciseBody));
+            else {
+                node = TS.visitNode(node, node => {
+                    const res = visitGeneric(node, {});
+                    hasChildIdentifier = hasChildIdentifier || res.hasChildIdentifier || TS.isIdentifier(node);
+                    return res.node;
+                });
             }
-            return TS.visitNode(node, node => visitGeneric(node, {}));
+            return { hasChildIdentifier, node };
         };
-        return TS.visitNode(sourceFile, node => visitGeneric(node, {}), TS.isSourceFile);
+        return TS.visitNode(sourceFile, node => visitGeneric(node, {}).node, TS.isSourceFile);
     };
 };
 exports.transformer = transformer;

package/lib/jsx-runtime.js

@@ -4,11 +4,16 @@ exports.JSX = exports.jsx = exports.Fragment = void 0;
 exports.jsxs = jsxs;
 const NesquickComponent_1 = require("./NesquickComponent");
 const NesquickFragment_1 = require("./NesquickFragment");
+const jsx_runtime_1 = require("./no-transformer/jsx-runtime");
+const propsSpreadSymbol = Symbol.for("$nesquickSpreadProps");
 exports.Fragment = Symbol();
 function jsxs(type, props, key) {
     if (type === exports.Fragment) {
         return new NesquickFragment_1.NesquickFragment(props.children);
     }
+    if (props[propsSpreadSymbol]) {
+        (0, jsx_runtime_1.functionizeProps)(props);
+    }
     if (key !== undefined) {
         props.key = key;
     }

package/lib/no-transformer/jsx-runtime.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSX = exports.jsx = exports.Fragment = void 0;
+exports.functionizeProps = functionizeProps;
 exports.jsxs = jsxs;
 const NesquickComponent_1 = require("../NesquickComponent");
 const NesquickFragment_1 = require("../NesquickFragment");
 exports.Fragment = Symbol();
 function functionizeProps(props) {
     for (const k in props) {
-        if (typeof props[k] !== "function") {
+        if (k !== "children" && typeof props[k] !== "function") {
             const v = props[k];
             props[k] = () => v;
         }

package/lib/types/NesquickFragment.d.ts

@@ -1,11 +1,11 @@
 import { JSX } from "./jsx-runtime";
-import { NesquickComponent, NesquickParent, VeactDocument } from "./NesquickComponent";
+import { Child, Children, NesquickComponent, NesquickParent, VeactDocument } from "./NesquickComponent";
 export declare class NesquickFragment extends NesquickComponent<{
-    children: any[];
+    children: Child[];
 }> implements NesquickParent {
     private _lastNode;
     private _fragment;
-    constructor(children: any[]);
+    constructor(children: Children);
     render(document: VeactDocument): Node;
     getDocument(): Document | null;
     getParent(): Node | null;

package/lib/types/State.d.ts

@@ -1,4 +1,6 @@
-export type State<T> = [get: () => T, set: (value: T) => void];
+export type Getter<T> = () => T;
+export type Setter<T> = (value: T) => void;
+export type State<T> = [get: Getter<T>, set: Setter<T>];
 export type Subscription<T> = {
     cb: () => T;
     reaction: ((data: T, isState: boolean) => void) | null;

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

@@ -1,7 +1,10 @@
 import { FunctionComponent, ComponentProps, NesquickComponent } from "./NesquickComponent";
 import { NesquickFragment } from "./NesquickFragment";
+declare const propsSpreadSymbol: unique symbol;
 export declare const Fragment: unique symbol;
-export declare function jsxs<P extends ComponentProps>(type: string | FunctionComponent<P> | typeof Fragment, props: P, key?: string | number | null): NesquickFragment | NesquickComponent<P>;
+export declare function jsxs<P extends ComponentProps & {
+    [propsSpreadSymbol]?: true;
+}>(type: string | FunctionComponent<P> | typeof Fragment, props: P, key?: string | number | null): NesquickFragment | NesquickComponent<P>;
 export declare const jsx: typeof jsxs;
 type HasUndefined<T, K extends keyof T> = {
     [L in K]-?: T[K] | undefined;
@@ -14,7 +17,7 @@ type WrappedFunction<T> = (() => T) & {
 };
 type UserProp<T> = T extends (...args: any[]) => any ? T : WrappedFunction<T>;
 type UserProps<T> = {
-    readonly [K in keyof T]: HasUndefined<T, K> extends true ? UserProp<T[K] | undefined> : UserProp<Exclude<T[K], undefined>>;
+    readonly [K in keyof T]: K extends keyof JSX.ElementChildrenAttribute ? T[K] : HasUndefined<T, K> extends true ? UserProp<T[K] | undefined> : UserProp<Exclude<T[K], undefined>>;
 };
 type JSXProp<T> = T extends {
     readonly [WrappedFunctionType]?: infer R;

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

@@ -1,6 +1,7 @@
 import { FunctionComponent, ComponentProps, NesquickComponent } from "../NesquickComponent";
 import { NesquickFragment } from "../NesquickFragment";
 export declare const Fragment: unique symbol;
+export declare function functionizeProps(props: ComponentProps): void;
 export declare function jsxs<P extends ComponentProps>(type: string | FunctionComponent<P> | typeof Fragment, props: P, key?: string | number | null): NesquickFragment | NesquickComponent<P>;
 export declare const jsx: typeof jsxs;
 type HasUndefined<T, K extends keyof T> = {
@@ -14,7 +15,7 @@ type WrappedFunction<T> = (() => T) & {
 };
 type UserProp<T> = T extends (...args: infer A) => infer R ? (((...args: A) => R) | T) : WrappedFunction<T>;
 type UserProps<T> = {
-    readonly [K in keyof T]: HasUndefined<T, K> extends true ? UserProp<T[K] | undefined> : UserProp<Exclude<T[K], undefined>>;
+    readonly [K in keyof T]: K extends keyof JSX.ElementChildrenAttribute ? T[K] : HasUndefined<T, K> extends true ? UserProp<T[K] | undefined> : UserProp<Exclude<T[K], undefined>>;
 };
 type JSXProp<T> = T extends {
     readonly [WrappedFunctionType]?: infer R;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nesquick",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "React-like library with focus on drawing performance",
   "types": "./lib/types",
   "main": "./lib",