babel-plugin-vasille 5.1.0 → 5.1.2

package/README.md

@@ -29,7 +29,6 @@
     - [1.0 - 1.2](#10---12)
   - [Questions](#questions)
 
-
 <hr>
 
 ## Installation
@@ -47,37 +46,41 @@ $ npm create steel-frame
 ```
 
 ### Full documentation:
-* [Learn `SteelFrameKit` in 5 minutes](https://github.com/vasille-js/vasille-js/blob/v5/doc/V4-API.md)
-* [Router Documentation](https://github.com/vasille-js/vasille-js/blob/v5/doc/Router-API.md)
-* [Compostion functions](https://github.com/vasille-js/vasille-js/blob/v5/doc/Compositions.md)
-* [Dependency injection](https://github.com/vasille-js/vasille-js/blob/v5/doc/Context.md)
+
+- [Learn `SteelFrameKit` in 5 minutes](https://github.com/vasille-js/vasille-js/blob/v5/doc/V4-API.md)
+- [Router Documentation](https://github.com/vasille-js/vasille-js/blob/v5/doc/Router-API.md)
+- [Compostion functions](https://github.com/vasille-js/vasille-js/blob/v5/doc/Compositions.md)
+- [Dependency injection](https://github.com/vasille-js/vasille-js/blob/v5/doc/Context.md)
 
 ### Examples
-* [TypeScript Example](https://github.com/vasille-js/example-typescript)
-* [JavaScript Example](https://github.com/vasille-js/example-javascript)
+
+- [TypeScript Example](https://github.com/vasille-js/example-typescript)
+- [JavaScript Example](https://github.com/vasille-js/example-javascript)
 
 <hr>
 
 ## How SAFE is SteelFrameKit
 
 The safe of your application is ensured by
-* `100%` coverage of code by unit tests.
+
+- `100%` coverage of code by unit tests.
   Each function, each branch is working as designed.
-* OOP, DRY, KISS and SOLID principles are applied.
-* `strong typing` makes your javascript/typescript code safe as C++ code.
-All entities of `SteelFrameKit` core library are strongly typed, including:
-  * data fields & properties.
-  * computed properties (function parameters and result).
-  * methods.
-  * events (defined handlers & event emit).
-  * DOM events & DOM operation (attributing, styling, etc.).
-  * slots of components.
-  * references to children.
-* No asynchronous code, when the line of code is executed, the DOM and reactive things are already synced.
+- OOP, DRY, KISS and SOLID principles are applied.
+- `strong typing` makes your code safe.
+  All entities of `SteelFrameKit` core library are strongly typed, including:
+  - data fields & properties.
+  - computed properties (function parameters and result).
+  - methods.
+  - events (defined handlers & event emit).
+  - DOM events & DOM operation (attributing, styling, etc.).
+  - slots of components.
+  - references to children.
+- No asynchronous code, when the line of code is executed, the DOM and reactive things are already synced.
 
 ## How INTUITIVE is SteelFrameKit
 
 There is the "Hello World":
+
 ```typescript jsx
 import { compose, mount } from "steel-frame";
 
@@ -91,35 +94,37 @@ mount(document.body, App, {});
 ## How POWERFUL is SteelFrameKit
 
 All of these are supported:
-* Components.
-* Reactive values (observables).
-* Inline computed values.
-* Multiline computed values.
-* HTML tags.
-* Component custom slots.
-* 2-way data binding in components.
-* Logic block (if, else).
-* Loops (array, map, set).
-* Dependency injection.
+
+- Components.
+- Reactive values (observables).
+- Inline computed values.
+- Multiline computed values.
+- HTML tags.
+- Component custom slots.
+- 2-way data binding in components.
+- Logic block (if, else).
+- Loops (array, map, set).
+- Dependency injection.
 
 <hr>
 
 ## Road map
 
-* [x] `100%` Test Coverage for core Library v3.
-* [x] Develop the `JSX` library.
-* [x] `100%` Test Coverage for the JSX library.
-* [x] Develop the `Babel Plugin`.
-* [x] `100%` Test Coverage fot babel plugin.
-* [x] Add CSS support (define styles in components).
-* [x] Add router.
-* [x] Add SSG (static site generation).
-* [ ] Develop tools extension for debugging (WIP).
-* [ ] Add SSR (server side rendering).
+- [x] `100%` Test Coverage for core Library v3.
+- [x] Develop the `JSX` library.
+- [x] `100%` Test Coverage for the JSX library.
+- [x] Develop the `Babel Plugin`.
+- [x] `100%` Test Coverage fot babel plugin.
+- [x] Add CSS support (define styles in components).
+- [x] Add router.
+- [x] Add SSG (static site generation).
+- [ ] Develop tools extension for debugging (WIP).
+- [ ] Add SSR (server side rendering).
 
 ## Change log
 
 We respect semantic versioning:
+
 - A major version is increased when we make incompatible API changes.
 - A minor version is increased when we add functionality.
 - Patch version is increased when we fix bugs.
@@ -165,4 +170,4 @@ _Web components as custom tags are supported in any version._
 
 If you have questions, feel free to contact the maintainer of the project:
 
-* [Author's Email](mailto:vas.lixcode@gmail.com)
+- [Author's Email](mailto:vas.lixcode@gmail.com)

package/lib/communication.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.js

@@ -14,6 +14,8 @@ function default_1() {
                     headTag: !!params.opts.headTag,
                     bodyTag: !!params.opts.bodyTag,
                     shadow: !!params.opts.shadow,
+                    throwAtFirstError: !!params.opts.throwAtFirstError,
+                    reporter: typeof params.opts.reporter === "function" ? params.opts.reporter : undefined,
                 });
             },
         },

package/lib/jsx.js

@@ -284,7 +284,7 @@ function transformJsxElement(path, conditions, internal) {
                             }
                         }
                         else {
-                            (0, lib_js_1.err)(lib_js_1.Errors.TokenNotSupported, valuePath, "Expected event handler", internal);
+                            (0, lib_js_1.err)(lib_js_1.Errors.TokenNotSupported, attrPath, "Expected event handler", internal);
                         }
                     }
                     else if (name.name === "class") {
@@ -349,7 +349,7 @@ function transformJsxElement(path, conditions, internal) {
                         // class={`a ${b}`}
                         else if (expressionPath && expressionPath.isExpression()) {
                             if ((0, lib_js_1.exprCall)(expressionPath, expressionPath.node, internal, { strong: true }, expressionPath.node)) {
-                                console.warn(attrPath.buildCodeFrameError("Vasille: This will slow down your application"));
+                                internal.reportError("This will slow down your application", attrPath.node);
                             }
                             attrs.push(t.objectProperty(t.identifier("class"), expressionPath.node));
                         }
@@ -427,7 +427,7 @@ function transformJsxElement(path, conditions, internal) {
                             /* istanbul ignore else */
                             if (expressionPath && expressionPath.isExpression()) {
                                 if ((0, lib_js_1.exprCall)(expressionPath, expressionPath.node, internal, { strong: true }, expressionPath.node)) {
-                                    console.warn(attrPath.buildCodeFrameError("Vasille: This will slow down your application"));
+                                    internal.reportError("This will slow down your application", attrPath.node);
                                 }
                                 attrs.push(t.objectProperty(t.identifier("style"), expressionPath.node));
                             }
@@ -601,6 +601,7 @@ function transformJsxElement(path, conditions, internal) {
                 (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, path, "Malformed JSX If tag is missing", internal);
             }
             if (mapped === "If" || mapped === "ElseIf") {
+                /* istanbul ignore else */
                 if (t.isExpression(condition) && (t.isFunctionExpression(slot) || t.isArrowFunctionExpression(slot))) {
                     if (!conditions.cases) {
                         conditions.cases = [{ condition, slot }];

package/lib/lib.js

@@ -47,6 +47,7 @@ exports.processModelCall = processModelCall;
 exports.checkReactiveName = checkReactiveName;
 exports.checkNonReactiveName = checkNonReactiveName;
 exports.toKebabCase = toKebabCase;
+exports.nameIsRestricted = nameIsRestricted;
 const t = __importStar(require("@babel/types"));
 const expression_js_1 = require("./expression.js");
 const internal_js_1 = require("./internal.js");
@@ -67,10 +68,7 @@ function err(e, node, content, internal, ret) {
     Error.stackTraceLimit = 0;
     const error = node.buildCodeFrameError(`Vasille[${e}]{${Errors[e]}}: ${content}`, Error);
     Error.stackTraceLimit = limit;
-    if (!internal.firstError) {
-        internal.firstError = error;
-    }
-    console.log(error);
+    internal.reportError(`${Errors[e]}: ${content}`, node.node, error);
     return ret;
 }
 function processCalculateCall(path, internal, area, name) {
@@ -202,3 +200,6 @@ function toKebabCase(name) {
     }
     return fixed;
 }
+function nameIsRestricted(name) {
+    return name.endsWith("Model") || name.startsWith("prompt");
+}

package/lib/mesh.js

@@ -242,6 +242,12 @@ function meshExpression(nodePath, internal) {
                     (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "Prompts can be constructed only from components", internal);
                 }
                 path.node.arguments.unshift(internal_js_1.ctx);
+                if (internal.devLayer) {
+                    while (path.node.arguments.length < 3) {
+                        path.node.arguments.push(t.buildUndefinedNode());
+                    }
+                    path.node.arguments.push((0, transformer_1.nodeToStaticPosition)(path.node));
+                }
             }
             // dependency injection
             else if (internal.isComposing &&
@@ -445,6 +451,9 @@ function ignoreParams(path, internal, allowReactiveId) {
         if (!allowReactiveId || !allowReactiveId.includes("id")) {
             (0, lib_js_1.checkNonReactiveName)(path, internal);
         }
+        if ((0, lib_js_1.nameIsRestricted)(path.node.name)) {
+            (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, path, "This name is restricted (start with `prompt` or ends with `Model`)", internal);
+        }
     }
     // param is object destruction
     else if (path.isObjectPattern()) {
@@ -953,6 +962,9 @@ function meshFunction(path, internal) {
         if (idPath.isIdentifier()) {
             internal.stack.set(path.node.id.name, {});
             (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+            if (internal.devLayer) {
+                path.insertAfter(internal.setupPosition(idPath.node, path.node));
+            }
         }
     }
     internal.stack.push();
@@ -1118,9 +1130,6 @@ function composeStatement(path, internal) {
                         const argument = init.arguments[0];
                         const isReactive = (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { name: idName(), strong: true }, declaration.node);
                         meshInit = !isReactive;
-                        if (!isReactive) {
-                            declaration.get("init").replaceWith((0, lib_js_1.ref)(argument, internal, declaration.node, idName()));
-                        }
                         (0, lib_js_1.checkReactiveName)(idPath, internal);
                     }
                     // let y = ref(2)

package/lib/transformer.js

@@ -194,6 +194,7 @@ function transformProgram(path, filename, opts) {
         executionPosition: "VasilleExePos",
         runFn: "VasilleRun",
         wrapFn: "VasilleWrap",
+        setupPosition: "VasilleSetupPosition",
         shareStateById: "VasilleState",
         positionedText: "VasillePosText",
         earlyInspector: "VasilleInspector",
@@ -206,6 +207,7 @@ function transformProgram(path, filename, opts) {
         }
         return t.callExpression(t.identifier(ids[key]), args);
     }
+    const reports = [];
     const internal = {
         stack: new internal_js_1.StackedStates(),
         mapping: new Map(),
@@ -291,12 +293,12 @@ function transformProgram(path, filename, opts) {
             return t.callExpression(t.memberExpression(left, t.identifier("update")), [right, getExecutionPosition(assign)]);
         },
         wrapFunctionBody(fn) {
-            const params = fn.params.map((item) => {
-                return t.isFunctionParameter(item) ? item : item.parameter;
-            });
-            const body = fn.body;
-            const args = t.identifier("VasilleArgs");
             if (opts.devLayer) {
+                const params = fn.params.map((item) => {
+                    return t.isFunctionParameter(item) ? item : item.parameter;
+                });
+                const body = fn.body;
+                const args = t.identifier("VasilleArgs");
                 fn.body = t.blockStatement([
                     t.returnStatement(call("runFn", [
                         t.arrowFunctionExpression(params, body, fn.async),
@@ -316,6 +318,9 @@ function transformProgram(path, filename, opts) {
             }
             return fn;
         },
+        setupPosition(target, area) {
+            return call("setupPosition", [target, nodeToStaticPosition(area)]);
+        },
         shareStateById(value, name) {
             return shareStateById(value, name);
         },
@@ -326,6 +331,27 @@ function transformProgram(path, filename, opts) {
             used.add("earlyInspector");
             return t.identifier(ids["earlyInspector"]);
         },
+        reportError(message, node, e) {
+            const pos = node.loc;
+            /* istanbul ignore else */
+            if (pos) {
+                reports.push({
+                    message: message,
+                    from: [pos.start.line, pos.start.column],
+                    to: [pos.end.line, pos.end.column],
+                    class: e ? "error" : "warning",
+                });
+            }
+            if (e) {
+                if (opts.throwAtFirstError) {
+                    throw e;
+                }
+                console.error(e);
+            }
+            else {
+                console.warn(message);
+            }
+        },
     };
     function getCtx() {
         if (internal.isComposing)
@@ -365,8 +391,13 @@ function transformProgram(path, filename, opts) {
         }
     }
     updateImports(path, internal, ids, used);
-    if (internal.firstError)
-        throw internal.firstError;
+    opts.reporter?.({
+        filePath: filename,
+        reports: reports,
+    });
+    if (reports.some(item => item.class === "error")) {
+        throw new Error("Compilation failed");
+    }
     if (opts.devLayer) {
         path.node.body.unshift(t.variableDeclaration("const", [t.variableDeclarator(filePathId, t.stringLiteral(internal.steelFilePath))]));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-vasille",
-  "version": "5.1.0",
+  "version": "5.1.2",
   "description": "Convert Vasille Meta Language code to pure JavaScript",
   "main": "lib/index.js",
   "type": "commonjs",
@@ -8,11 +8,13 @@
     "import": "./lib/index.js",
     "browser": "./lib/index.js",
     "node": "./lib/index.js",
-    "require": "./lib/index.js"
+    "require": "./lib/index.js",
+    "types": "./types/index.d.ts"
   },
   "scripts": {
     "prepack": "cp -f ../README.md ./README.md",
     "prettier": "prettier src test/**/*.ts* test/*.ts --write",
+    "prebuild": "rm -rf lib types",
     "build": "tsc --build tsconfig-build.json",
     "tsc-tests": "tsc --build test/tsconfig.json",
     "test": "jest",
@@ -26,7 +28,7 @@
     "babel"
   ],
   "author": "lixcode",
-  "license": "MIT",
+  "license": "LGPL-2.1-only",
   "bugs": {
     "url": "https://github.com/vasille-js/vasille-js/issues"
   },

package/types/call.d.ts

@@ -0,0 +1,14 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+export type FnNames = "compose" | "view" | "component" | "store" | "model" | "screen" | "page" | "modal" | "prompt" | "awaited" | "calculate" | "forward" | "watch" | "ref" | "bind" | "raw" | "arrayModel" | "setModel" | "mapModel" | "beforeMount" | "afterMount" | "beforeDestroy" | "router" | "theme" | "dark" | "mobile" | "tablet" | "laptop" | "prefersDark" | "prefersLight" | "styleSheet" | "share" | "receive" | "impute";
+export declare const composeFunctions: ["compose", "store", "model", "view", "component", "page", "modal", "prompt", "screen"];
+export declare const refFunctions: ["ref"];
+export declare const asyncFunctions: ["awaited"];
+export declare const bindFunctions: ["watch", "calculate", "bind"];
+export declare const modelFunctions: ["arrayModel", "mapModel", "setModel"];
+export declare const composeOnly: ["router", "beforeMount", "afterMount", "beforeDestroy"];
+export declare const styleOnly: ["theme", "dark", "mobile", "tablet", "laptop", "prefersDark", "prefersLight", "styleSheet"];
+export declare const dependencyInjections: ["share", "receive", "impute"];
+export declare const hintFunctions: FnNames[];
+export declare function calls(path: NodePath<types.CallExpression>, names: FnNames[], internal: Internal): boolean;
+export declare function calls(path: NodePath<types.Expression | null | undefined>, names: FnNames[], internal: Internal): path is NodePath<types.CallExpression>;

package/types/communication.d.ts

@@ -0,0 +1,11 @@
+export interface CompilationErrorReport {
+    from: [number, number];
+    to: [number, number];
+    message: string;
+    class: "error" | "warning";
+}
+export interface CompilationErrorReports {
+    filePath: string;
+    reports: CompilationErrorReport[];
+}
+export type CompilationErrorReporter = (reports: CompilationErrorReports) => void;

package/types/css-transformer.d.ts

@@ -0,0 +1,3 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+export declare function findStyleInNode(path: NodePath<types.Node | null | undefined>, internal: Internal): boolean;

package/types/expression.d.ts

@@ -0,0 +1,27 @@
+import { NodePath, types } from "@babel/core";
+import { Internal, StackedStates } from "./internal.js";
+export interface Dependency {
+    node: types.Expression;
+    paramName: types.Identifier;
+}
+export interface Search {
+    found: Map<string, Dependency>;
+    external: Internal;
+    self: types.Expression | null;
+    inserted: Set<types.Expression>;
+    stack: StackedStates;
+}
+export declare function nodeIsMeshed(path: NodePath<types.Node | null | undefined>): boolean;
+export declare function idIsIValue(path: NodePath<types.Identifier>): boolean;
+export declare function memberIsIValue(node: types.MemberExpression | types.OptionalMemberExpression): boolean;
+export declare function memberIsIValueInExpr(path: NodePath<types.MemberExpression | types.OptionalMemberExpression>, search: Search): boolean;
+export declare function exprIsSure(path: NodePath<types.Expression | null | undefined>, internal: Internal): boolean | 1;
+export declare function checkNode(path: NodePath<types.Node | null | undefined>, internal: Internal, area: types.Node, name?: string): Search;
+export declare function checkOrIgnoreAllExpressions<T extends types.Node>(nodePaths: NodePath<types.Expression | null | T>[], search: Search): void;
+export declare function checkAllExpressions(nodePaths: NodePath<types.Expression | null>[], search: Search): void;
+export declare function checkAllUnknown(paths: NodePath<types.SpreadElement | types.ArgumentPlaceholder | types.Expression | null>[], internal: Search): void;
+export declare function checkOrIgnoreExpression<T extends types.Node>(path: NodePath<types.Expression | null | undefined | T>, search: Search): void;
+export declare function checkExpression(nodePath: NodePath<types.Expression | null | undefined>, search: Search): void;
+export declare function checkStatements(paths: NodePath<types.Statement>[], search: Search): void;
+export declare function checkStatement(path: NodePath<types.Statement | null | undefined>, search: Search): void;
+export declare function checkFunction(path: NodePath<types.ArrowFunctionExpression | types.FunctionExpression | types.FunctionDeclaration | types.ObjectMethod>, search: Search): void;

package/types/index.d.ts

@@ -0,0 +1,19 @@
+import * as Babel from "@babel/core";
+export default function (): Babel.PluginObj<{
+    file: {
+        opts: {
+            filename: string;
+        };
+    };
+    opts: {
+        devLayer: unknown;
+        strictFolders: unknown;
+        replaceWeb: unknown;
+        headTag: unknown;
+        bodyTag: unknown;
+        shadow: unknown;
+        throwAtFirstError: unknown;
+        reporter: unknown;
+    };
+}>;
+export type { CompilationErrorReporter, CompilationErrorReport, CompilationErrorReports } from "./communication";

package/types/internal.d.ts

@@ -0,0 +1,55 @@
+import { NodePath, types } from "@babel/core";
+import { TSTypeElement } from "@babel/types";
+export type VariableState = Record<string, 1>;
+export declare class StackedStates {
+    private maps;
+    private checkingIndex;
+    constructor();
+    push(startChecking?: boolean): void;
+    pop(): void;
+    get(name: string, checkingContextOnly?: boolean): VariableState | undefined;
+    set(name: string, state: VariableState): void;
+}
+export interface Internal {
+    mapping: Map<string, string>;
+    interfaces: Map<string, TSTypeElement[]>;
+    componentsImports: Map<string, string>;
+    stack: StackedStates;
+    global: string;
+    prefix: string;
+    importStatement: NodePath<types.ImportDeclaration> | null;
+    stateOnly: boolean;
+    isComposing?: boolean;
+    isFunctionParsing?: boolean;
+    filename: string;
+    steelFilePath: string;
+    devLayer: boolean;
+    strictFolders: boolean;
+    stylesConnected: boolean;
+    replaceWeb: string;
+    headTag?: boolean;
+    bodyTag?: boolean;
+    shadow?: boolean;
+    reportError(message: string, node: types.Node, e?: Error): void;
+    ref(arg: types.Expression | null, area: types.Node, name: string | undefined): types.Expression;
+    expr(func: types.Expression, values: types.Expression[], codes: string[], area: types.Node, name: string | undefined): types.Expression;
+    setModel(arg: types.Expression | types.SpreadElement | types.ArgumentPlaceholder | null, usage: types.Node, name: string | undefined): types.Expression;
+    mapModel(arg: types.Expression | types.SpreadElement | types.ArgumentPlaceholder | null, usage: types.Node, name: string | undefined): types.Expression;
+    arrayModel(arg: types.Expression | types.SpreadElement | types.ArgumentPlaceholder | null, usage: types.Node, name: string | undefined): types.Expression;
+    ensure(arg: types.MemberExpression | types.OptionalMemberExpression, area: types.Node): types.Expression;
+    match(name: types.Expression, arg: types.Expression, area: types.Node): types.CallExpression;
+    set(obj: types.Expression, field: types.Expression, value: types.Expression, area: types.Node): types.CallExpression;
+    Switch(arg: types.ObjectExpression): types.CallExpression;
+    safe(arg: types.FunctionExpression | types.ArrowFunctionExpression): types.CallExpression;
+    updateIValue(assign: types.AssignmentExpression, left: types.Expression, right: types.Expression): types.Expression;
+    wrapFunctionBody(fn: types.FunctionDeclaration | types.ObjectMethod | types.ClassMethod | types.ClassPrivateMethod): void;
+    setupPosition(target: types.Expression, area: types.Node): types.Expression;
+    wrapFunction(fn: types.FunctionExpression | types.ArrowFunctionExpression): types.Node;
+    shareStateById(value: types.Expression, name: string): types.Expression;
+    positionedText(text: types.Expression, area: types.Node): types.Expression;
+    earlyInspector(): types.Expression;
+}
+export declare const ctx: types.Identifier;
+export declare const runner: types.MemberExpression;
+export declare const inspector: types.MemberExpression;
+export declare const V: types.Identifier;

package/types/jsx-detect.d.ts

@@ -0,0 +1,3 @@
+import { types } from "@babel/core";
+export declare function exprHasJsx(node: types.Expression): boolean;
+export declare function bodyHasJsx(node: types.BlockStatement | types.Expression): boolean;

package/types/jsx.d.ts

@@ -0,0 +1,11 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+export interface ConditionCollection {
+    cases: {
+        condition: types.Expression;
+        slot: types.FunctionExpression | types.ArrowFunctionExpression;
+    }[] | null;
+}
+export declare function transformJsx(path: NodePath<types.JSXElement | types.JSXFragment>, conditions: ConditionCollection, internal: Internal): types.Statement[];
+export declare function transformJsxArray(paths: NodePath<types.JSXText | types.JSXExpressionContainer | types.JSXSpreadChild | types.JSXElement | types.JSXFragment>[], internal: Internal): types.Statement[];
+export declare function processConditions(conditions: ConditionCollection, internal: Internal, _default?: types.FunctionExpression | types.ArrowFunctionExpression): types.Statement[];

package/types/lib.d.ts

@@ -0,0 +1,30 @@
+import { NodePath, types } from "@babel/core";
+import { Identifier } from "@babel/types";
+import { Dependency } from "./expression.js";
+import { Internal } from "./internal.js";
+export declare enum Errors {
+    IncorrectArguments = 1,
+    IncompatibleContext = 2,
+    TokenNotSupported = 3,
+    Dilemma = 4,
+    ParserError = 5,
+    RulesOfVasille = 6
+}
+export declare function err(e: Errors, node: NodePath<unknown>, content: string, internal: Internal, ret?: undefined): void;
+export declare function err<T>(e: Errors, node: NodePath<unknown>, content: string, internal: Internal, ret: T): T;
+export declare function processCalculateCall(path: NodePath<types.CallExpression>, internal: Internal, area: types.Node, name: string | undefined): boolean;
+export declare function parseCalculateCall(path: NodePath<types.Expression | null | undefined>, internal: Internal, area: types.Node, name: string | undefined): boolean;
+export declare function bindCall(path: NodePath<types.Expression | null | undefined>, expr: types.Expression | null | undefined, data: Map<string, Dependency>, internal: Internal, name?: string): boolean;
+export declare function exprCall(path: NodePath<types.Expression | null | undefined>, expr: types.Expression | null | undefined, internal: Internal, opts: {
+    name?: string;
+    strong?: boolean;
+}, area: types.Node): boolean;
+export declare function ref(expr: types.Node | null | undefined, internal: Internal, area: types.Node, name?: string): types.Expression;
+export declare function arrayModel(args: types.CallExpression["arguments"], usage: types.Node, internal: Internal, name?: string): types.Expression;
+export declare function setModel(args: types.CallExpression["arguments"], usage: types.Node, internal: Internal, name?: string): types.Expression;
+export declare function mapModel(args: types.CallExpression["arguments"], usage: types.Node, internal: Internal, name?: string): types.Expression;
+export declare function processModelCall(path: NodePath<types.CallExpression | types.NewExpression>, usage: types.Node, type: "Map" | "Set" | "Array", isConst: boolean, internal: Internal, name?: string): void;
+export declare function checkReactiveName(idPath: NodePath<unknown>, internal: Internal): void;
+export declare function checkNonReactiveName(idPath: NodePath<Identifier>, internal: Internal): void;
+export declare function toKebabCase(name: string): string;
+export declare function nameIsRestricted(name: string): boolean;

package/types/mesh.d.ts

@@ -0,0 +1,19 @@
+import { NodePath, types } from "@babel/core";
+import { Internal, VariableState } from "./internal.js";
+export declare function meshOrIgnoreAllExpressions<T extends types.Node>(nodePaths: NodePath<types.Expression | null | T>[], internal: Internal): void;
+export declare function meshAllExpressions(nodePaths: NodePath<types.Expression | null>[], internal: Internal): void;
+export declare function meshComposeCall(name: string | null | undefined, path: NodePath<types.Node | null | undefined>, internal: Internal, isExported?: boolean): void;
+export declare function meshAllUnknown(paths: NodePath<types.SpreadElement | types.ArgumentPlaceholder | types.Expression | null>[], internal: Internal): void;
+export declare function meshLValue(path: NodePath<types.LVal | types.Expression | types.VoidPattern | null | undefined>, internal: Internal): void;
+export declare function meshOrIgnoreExpression<T extends types.Node>(path: NodePath<types.Expression | types.VoidPattern | null | undefined | T>, internal: Internal): void;
+export declare function meshExpression(nodePath: NodePath<types.Expression | null | undefined>, internal: Internal): void;
+export declare function meshStatements(paths: NodePath<types.Statement>[], internal: Internal): void;
+export declare function ignoreParams(path: NodePath<types.LVal | types.VoidPattern | null | undefined>, internal: Internal, allowReactiveId: false | ("id" | "array")[]): void;
+export declare function reactiveArrayPattern(path: NodePath<types.LVal | types.OptionalMemberExpression | types.VoidPattern>, internal: Internal): void;
+export declare function processObjectExpression(path: NodePath<types.ObjectExpression>, internal: Internal): VariableState;
+export declare function meshStatement(path: NodePath<types.Statement | null | undefined>, internal: Internal): void;
+export declare function meshFunction(path: NodePath<types.ArrowFunctionExpression | types.FunctionExpression | types.FunctionDeclaration | types.ObjectMethod | types.ClassMethod | types.ClassPrivateMethod>, internal: Internal): void;
+export declare function composeExpression(path: NodePath<types.Expression | null | undefined>, internal: Internal): void;
+export declare function composeStatements(paths: NodePath<types.Statement | null | undefined>[], internal: Internal): void;
+export declare function composeStatement(path: NodePath<types.Statement | null | undefined>, internal: Internal): void;
+export declare function compose(path: NodePath<types.ArrowFunctionExpression | types.FunctionExpression>, internal: Internal, isInternalSlot: boolean, isSlot: boolean): void;

package/types/order-check.d.ts

@@ -0,0 +1,3 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal";
+export declare function checkOrder(paths: NodePath<types.Statement | null | undefined>[], internal: Internal): void;

package/types/process-types.d.ts

@@ -0,0 +1,15 @@
+import { types } from "@babel/core";
+import { TSTypeElement } from "@babel/types";
+import { Internal } from "./internal";
+declare const any = 0;
+declare const string = 1;
+declare const number = 2;
+declare const boolean = 3;
+type PropType = typeof string | typeof number | typeof boolean | typeof any;
+export declare function registerInterface(name: string, members: TSTypeElement[], internal: Internal): void;
+export declare function processUnion(type: types.TSUnionType): PropType;
+export declare function processType(type: types.TSType): PropType;
+export declare function processSignatures(members: TSTypeElement[]): types.ObjectExpression;
+export declare function processTypeLiteral(literal: types.TSTypeLiteral): types.ObjectExpression;
+export declare function processReference(id: types.TSTypeReference, internal: Internal): types.ObjectExpression | undefined;
+export {};

package/types/router.d.ts

@@ -0,0 +1,2 @@
+import { NodePath } from "@babel/core";
+export declare function routerReplace(path: NodePath<unknown>): void;

package/types/transformer.d.ts

@@ -0,0 +1,16 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+import { CompilationErrorReporter } from "./communication";
+export interface TransformerOptions {
+    devLayer: boolean;
+    strictFolders: boolean;
+    replaceWeb: string | undefined;
+    headTag: boolean;
+    bodyTag: boolean;
+    shadow: boolean;
+    reporter: CompilationErrorReporter | undefined;
+    throwAtFirstError: boolean;
+}
+export declare function nodeToStaticPosition(node: types.Node): types.ArrayExpression;
+export declare function transformProgram(path: NodePath<types.Program>, filename: string, opts: TransformerOptions): void;
+export declare function inspectorOf(internal: Internal): types.Expression;

package/types/utils.d.ts

@@ -0,0 +1,2 @@
+import { types } from "@babel/core";
+export declare function stringify(node: types.Expression | types.PrivateName): string;