babel-plugin-vasille 5.1.1 → 5.1.2

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

@@ -68,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) {

package/lib/mesh.js

@@ -1130,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

@@ -207,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(),
@@ -330,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)
@@ -369,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.1",
+  "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;