@esportsplus/template 0.38.2 → 0.40.0

package/build/compiler/{analyzer.d.ts → ts-analyzer.d.ts}

@@ -1,4 +1,4 @@
-import { COMPILER_TYPES } from '../constants.js';
 import { ts } from '@esportsplus/typescript';
-declare const analyze: (expr: ts.Expression, checker?: ts.TypeChecker) => COMPILER_TYPES;
+import { TYPES } from './constants.js';
+declare const analyze: (expr: ts.Expression, checker?: ts.TypeChecker) => TYPES;
 export { analyze };

package/build/compiler/{analyzer.js → ts-analyzer.js}

@@ -1,5 +1,5 @@
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES } from '../constants.js';
 import { ts } from '@esportsplus/typescript';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, TYPES } from './constants.js';
 function isTypeFunction(type, checker) {
     if (type.isUnion()) {
         for (let i = 0, n = type.types.length; i < n; i++) {
@@ -16,17 +16,17 @@ const analyze = (expr, checker) => {
         expr = expr.expression;
     }
     if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
-        return COMPILER_TYPES.Effect;
+        return TYPES.Effect;
     }
     if (ts.isCallExpression(expr) &&
         ts.isPropertyAccessExpression(expr.expression) &&
         ts.isIdentifier(expr.expression.expression) &&
-        expr.expression.expression.text === COMPILER_ENTRYPOINT &&
-        expr.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY) {
-        return COMPILER_TYPES.ArraySlot;
+        expr.expression.expression.text === ENTRYPOINT &&
+        expr.expression.name.text === ENTRYPOINT_REACTIVITY) {
+        return TYPES.ArraySlot;
     }
-    if (ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT) {
-        return COMPILER_TYPES.DocumentFragment;
+    if (ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === ENTRYPOINT) {
+        return TYPES.DocumentFragment;
     }
     if (ts.isNumericLiteral(expr) ||
         ts.isStringLiteral(expr) ||
@@ -35,31 +35,29 @@ const analyze = (expr, checker) => {
         expr.kind === ts.SyntaxKind.FalseKeyword ||
         expr.kind === ts.SyntaxKind.NullKeyword ||
         expr.kind === ts.SyntaxKind.UndefinedKeyword) {
-        return COMPILER_TYPES.Static;
+        return TYPES.Static;
     }
     if (ts.isTemplateExpression(expr)) {
-        return COMPILER_TYPES.Primitive;
+        return TYPES.Primitive;
     }
     if (ts.isConditionalExpression(expr)) {
         let whenFalse = analyze(expr.whenFalse, checker), whenTrue = analyze(expr.whenTrue, checker);
         if (whenTrue === whenFalse) {
             return whenTrue;
         }
-        if (whenTrue === COMPILER_TYPES.Effect || whenFalse === COMPILER_TYPES.Effect) {
-            return COMPILER_TYPES.Effect;
+        if (whenTrue === TYPES.Effect || whenFalse === TYPES.Effect) {
+            return TYPES.Effect;
         }
-        return COMPILER_TYPES.Unknown;
+        return TYPES.Unknown;
     }
     if (checker && (ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr) || ts.isCallExpression(expr))) {
         try {
-            let type = checker.getTypeAtLocation(expr);
-            if (isTypeFunction(type, checker)) {
-                return COMPILER_TYPES.Effect;
+            if (isTypeFunction(checker.getTypeAtLocation(expr), checker)) {
+                return TYPES.Effect;
             }
         }
-        catch {
-        }
+        catch { }
     }
-    return COMPILER_TYPES.Unknown;
+    return TYPES.Unknown;
 };
 export { analyze };

package/build/compiler/ts-parser.d.ts

@@ -14,7 +14,11 @@ type TemplateInfo = {
     node: ts.TaggedTemplateExpression;
     start: number;
 };
+declare const extractTemplateParts: (template: ts.TemplateLiteral) => {
+    expressions: ts.Expression[];
+    literals: string[];
+};
 declare const findHtmlTemplates: (sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => TemplateInfo[];
 declare const findReactiveCalls: (sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => ReactiveCallInfo[];
-export { findHtmlTemplates, findReactiveCalls };
+export { extractTemplateParts, findHtmlTemplates, findReactiveCalls };
 export type { ReactiveCallInfo, TemplateInfo };

package/build/compiler/ts-parser.js

@@ -1,38 +1,14 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '../constants.js';
-function isHtmlFromPackage(node, checker) {
-    if (node.text !== COMPILER_ENTRYPOINT) {
-        return false;
-    }
-    if (!checker) {
-        return true;
-    }
-    let symbol = checker.getSymbolAtLocation(node);
-    if (!symbol) {
-        return true;
-    }
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-        symbol = checker.getAliasedSymbol(symbol);
-    }
-    let declarations = symbol.getDeclarations();
-    if (!declarations || declarations.length === 0) {
-        return true;
-    }
-    for (let i = 0, n = declarations.length; i < n; i++) {
-        let filename = declarations[i].getSourceFile().fileName;
-        if (filename.includes(PACKAGE) || filename.includes('@esportsplus/template')) {
-            return true;
-        }
-    }
-    return false;
-}
+import { imports } from '@esportsplus/typescript/compiler';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, PACKAGE } from './constants.js';
 function visitReactiveCalls(node, calls, checker) {
     if (ts.isCallExpression(node) &&
         ts.isPropertyAccessExpression(node.expression) &&
         ts.isIdentifier(node.expression.expression) &&
-        node.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY &&
+        node.expression.name.text === ENTRYPOINT_REACTIVITY &&
         node.arguments.length === 2 &&
-        isHtmlFromPackage(node.expression.expression, checker)) {
+        node.expression.expression.text === ENTRYPOINT &&
+        (!checker || imports.includes(checker, node.expression.expression, PACKAGE, ENTRYPOINT))) {
         calls.push({
             arrayArg: node.arguments[0],
             callbackArg: node.arguments[1],
@@ -47,19 +23,11 @@ function visitTemplates(node, depth, templates, checker) {
     let nextDepth = (ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node))
         ? depth + 1
         : depth;
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && isHtmlFromPackage(node.tag, checker)) {
-        let expressions = [], literals = [], template = node.template;
-        if (ts.isNoSubstitutionTemplateLiteral(template)) {
-            literals.push(template.text);
-        }
-        else if (ts.isTemplateExpression(template)) {
-            literals.push(template.head.text);
-            for (let i = 0, n = template.templateSpans.length; i < n; i++) {
-                let span = template.templateSpans[i];
-                expressions.push(span.expression);
-                literals.push(span.literal.text);
-            }
-        }
+    if (ts.isTaggedTemplateExpression(node) &&
+        ts.isIdentifier(node.tag) &&
+        node.tag.text === ENTRYPOINT &&
+        (!checker || imports.includes(checker, node.tag, PACKAGE, ENTRYPOINT))) {
+        let { expressions, literals } = extractTemplateParts(node.template);
         templates.push({
             depth,
             end: node.end,
@@ -71,15 +39,29 @@ function visitTemplates(node, depth, templates, checker) {
     }
     ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates, checker));
 }
+const extractTemplateParts = (template) => {
+    let expressions = [], literals = [];
+    if (ts.isNoSubstitutionTemplateLiteral(template)) {
+        literals.push(template.text);
+    }
+    else if (ts.isTemplateExpression(template)) {
+        literals.push(template.head.text);
+        for (let i = 0, n = template.templateSpans.length; i < n; i++) {
+            let span = template.templateSpans[i];
+            expressions.push(span.expression);
+            literals.push(span.literal.text);
+        }
+    }
+    return { expressions, literals };
+};
 const findHtmlTemplates = (sourceFile, checker) => {
     let templates = [];
     visitTemplates(sourceFile, 0, templates, checker);
-    templates.sort((a, b) => a.depth !== b.depth ? b.depth - a.depth : a.start - b.start);
-    return templates;
+    return templates.sort((a, b) => a.depth !== b.depth ? b.depth - a.depth : a.start - b.start);
 };
 const findReactiveCalls = (sourceFile, checker) => {
     let calls = [];
     visitReactiveCalls(sourceFile, calls, checker);
     return calls;
 };
-export { findHtmlTemplates, findReactiveCalls };
+export { extractTemplateParts, findHtmlTemplates, findReactiveCalls };

package/build/constants.d.ts

@@ -1,25 +1,10 @@
 declare const ARRAY_SLOT: unique symbol;
 declare const CLEANUP: unique symbol;
-declare const COMPILER_ENTRYPOINT = "html";
-declare const COMPILER_ENTRYPOINT_REACTIVITY = "reactive";
-declare const COMPILER_NAMESPACE: string;
-declare const enum COMPILER_TYPES {
-    ArraySlot = "array-slot",
-    Attributes = "attributes",
-    Attribute = "attribute",
-    DocumentFragment = "document-fragment",
-    Effect = "effect",
-    Node = "node",
-    Primitive = "primitive",
-    Static = "static",
-    Unknown = "unknown"
-}
 declare const DIRECT_ATTACH_EVENTS: Set<string>;
 declare const LIFECYCLE_EVENTS: Set<string>;
-declare const PACKAGE = "@esportsplus/template";
 declare const SLOT_HTML = "<!--$-->";
 declare const STATE_HYDRATING = 0;
 declare const STATE_NONE = 1;
 declare const STATE_WAITING = 2;
 declare const STORE: unique symbol;
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/build/constants.js

@@ -1,22 +1,5 @@
-import { uid } from '@esportsplus/typescript/compiler';
 const ARRAY_SLOT = Symbol('template.array.slot');
 const CLEANUP = Symbol('template.cleanup');
-const COMPILER_ENTRYPOINT = 'html';
-const COMPILER_ENTRYPOINT_REACTIVITY = 'reactive';
-const COMPILER_NAMESPACE = uid('template');
-var COMPILER_TYPES;
-(function (COMPILER_TYPES) {
-    COMPILER_TYPES["ArraySlot"] = "array-slot";
-    COMPILER_TYPES["Attributes"] = "attributes";
-    COMPILER_TYPES["Attribute"] = "attribute";
-    COMPILER_TYPES["DocumentFragment"] = "document-fragment";
-    COMPILER_TYPES["Effect"] = "effect";
-    COMPILER_TYPES["Node"] = "node";
-    COMPILER_TYPES["Primitive"] = "primitive";
-    COMPILER_TYPES["Static"] = "static";
-    COMPILER_TYPES["Unknown"] = "unknown";
-})(COMPILER_TYPES || (COMPILER_TYPES = {}));
-;
 const DIRECT_ATTACH_EVENTS = new Set([
     'onblur',
     'onerror',
@@ -29,10 +12,9 @@ const DIRECT_ATTACH_EVENTS = new Set([
 const LIFECYCLE_EVENTS = new Set([
     'onconnect', 'ondisconnect', 'onrender', 'onresize', 'ontick'
 ]);
-const PACKAGE = '@esportsplus/template';
 const SLOT_HTML = '<!--$-->';
 const STATE_HYDRATING = 0;
 const STATE_NONE = 1;
 const STATE_WAITING = 2;
 const STORE = Symbol('template.store');
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/package.json

@@ -2,8 +2,8 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/queue": "^0.2.0",
-    "@esportsplus/reactivity": "^0.28.1",
-    "@esportsplus/typescript": "^0.25.0",
+    "@esportsplus/reactivity": "^0.29.9",
+    "@esportsplus/typescript": "^0.27.0",
     "@esportsplus/utilities": "^0.27.2",
     "serve": "^14.2.5"
   },
@@ -17,6 +17,10 @@
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
     },
+    "./compiler": {
+      "types": "./build/compiler/index.d.ts",
+      "default": "./build/compiler/index.js"
+    },
     "./compiler/tsc": {
       "types": "./build/compiler/plugins/tsc.d.ts",
       "default": "./build/compiler/plugins/tsc.js"
@@ -35,7 +39,7 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.38.2",
+  "version": "0.40.0",
   "scripts": {
     "build": "tsc",
     "build:test": "vite build --config test/vite.config.ts",