@mapl/web 0.2.0-alpha.3 → 0.2.0-alpha.5

package/README.md

@@ -50,51 +50,57 @@ export default router(
 
 // build.ts
 import app from './main.ts';
-import { compileToString } from '@mapl/web/compiler/jit';
+import { injectCompiledHandler } from '@mapl/web/compiler/jit';
+import { evaluateToString } from "runtime-compiler/jit";
 
-import { rolldown } from 'rolldown';
-import { minifySync } from '@swc/core';
-import { writeFileSync } from 'node:fs';
+import { rolldown } from "rolldown";
+import terser from '@rollup/plugin-terser';
+
+import { writeFileSync } from "node:fs";
 
 // Output file
-const ENTRY = ...;
+const OUTPUT = "./index.js";
+const HANDLER = injectCompiledHandler(app);
 
 writeFileSync(
-  ENTRY,
-  `
-    import "@mapl/web/compiler/aot-loader";
+  OUTPUT,
+  `import 'runtime-compiler/hydrate-loader';
+
+import app from './main.js';
+import hydrateRouter from '@mapl/web/compiler/aot';
+hydrateRouter(app);
 
-    import app from '${import.meta.resolve('./main.js')}';
-    import hydrate from '@mapl/web/compiler/aot';
+import { hydrate } from 'runtime-compiler/hydrate';
+(${evaluateToString()})(...hydrate());
 
-    export default {
-      fetch: (${compileToString(app)})(...hydrate(app))
-    };
-  `,
+import { getDependency } from 'runtime-compiler';
+export default {
+  fetch: getDependency(${HANDLER})
+};`,
 );
 const input = await rolldown({
   input: ENTRY,
-  treeshake: {
-    propertyReadSideEffects: false,
-    moduleSideEffects: false,
-  },
-  transform: {
-    typescript: {
-      rewriteImportExtensions: true,
-    },
-  },
+  plugins: [
+    terser({
+      module: true,
+      mangle: false,
+      compress: {
+        // passes should be at least 2
+        passes: 3,
+      },
+    }),
+  ],
+});
+const output = await input.write({
+  file: ENTRY,
+  inlineDynamicImports: true,
 });
-const output = await input.generate();
-const code = minifySync(output.output[0].code, {
-  module: true,
-  mangle: false,
-}).code;
-
-writeFileSync(ENTRY, code);
 ```
 
 Example output:
 ```js
+let isHydrating = !1;
+isHydrating = !0;
 var core_default = (middlewares, handlers, children) => [
   middlewares,
   handlers,
@@ -104,51 +110,46 @@ var core_default = (middlewares, handlers, children) => [
 let attach = (prop, f) => [1, f, prop],
   noType = { type: null },
   mergeData = (...dat) =>
-    0 === dat.length ? noType : Object.assign({ type: null }, ...dat);
-var main_default = core_default(
-  [
+    0 === dat.length ? noType : Object.assign({ type: null }, ...dat),
+  compiledDependencies = [],
+  externalDependencies = [],
+  getDependency = (c) => compiledDependencies[c],
+  injectExternalDependency = (e) => '_' + externalDependencies.push(e);
+var f,
+  handler,
+  main_default = core_default(
     [
-      0,
-      (c) => {
-        console.log(c.req);
-      },
+      ((f = (c) => {
+        console.log(c.req), getDependency(logID)(), getDependency(logID2)();
+      }),
+      [0, f]),
+      attach('id', () => performance.now()),
     ],
-    attach('id', () => performance.now()),
-  ],
-  [
-    ((path, handler, ...dat) => ['', path, handler, mergeData(...dat)])(
-      '/path',
-      (c) => c.id,
-    ),
-  ],
-  {
-    '/api': core_default(
-      [attach('body', async (c) => c.req.text())],
-      [
-        ((path, handler, ...dat) => ['POST', path, handler, mergeData(...dat)])(
-          '/body',
-          (c) => c.body,
-        ),
-      ],
-    ),
-  },
-);
-let AsyncFunction = (async () => {}).constructor,
-  compilerState = [, , , , ,],
-  compileErrorHandler$1 = (scope) =>
-    (scope[3] ??= compilerState[4](scope[2][0], scope[2][1], scope)),
+    [((handler = (c) => c.id), ['', '/path', handler, mergeData()])],
+    {
+      '/api': core_default(
+        [attach('body', async (c) => c.req.text())],
+        [['POST', '/body', (c) => c.body, mergeData()]],
+      ),
+    },
+  );
+let hooks,
+  _ = Symbol.for('@safe-std/error'),
+  AsyncFunction =
+    (injectExternalDependency((u) => Array.isArray(u) && u[0] === _),
+    (async () => {}).constructor),
+  compileErrorHandler = (scope) =>
+    (scope[3] ??= hooks.compileErrorHandler(scope[2][0], scope[2][1], scope)),
   clearErrorHandler = (scope) => {
     null != scope[2] && (scope[3] = null);
   },
-  createContext = (scope) =>
-    scope[1]
-      ? ''
-      : ((scope[1] = !0), clearErrorHandler(scope), compilerState[2]),
-  createAsyncScope = (scope) =>
-    scope[0]
-      ? ''
-      : ((scope[0] = !0), clearErrorHandler(scope), 'return (async()=>{'),
-  setTmp = (scope) => (scope[4] ? 't' : ((scope[4] = !0), 'let t')),
+  createContext = (scope) => (
+    scope[1] || ((scope[1] = !0), clearErrorHandler(scope)), ''
+  ),
+  createAsyncScope = (scope) => (
+    scope[0] || ((scope[0] = !0), clearErrorHandler(scope)), ''
+  ),
+  setTmp = (scope) => ((scope[4] = !0), ''),
   hydrateDependency = (group, scope, prefix) => {
     null != group[2] && ((scope[2] = group[2]), (scope[3] = null));
     for (let i = 0, middlewares = group[0]; i < middlewares.length; i++) {
@@ -157,21 +158,21 @@ let AsyncFunction = (async () => {}).constructor,
         id = middleware[0];
       -1 === id
         ? fn(scope)
-        : (compilerState[1].push(fn),
+        : (injectExternalDependency(fn),
           fn.length > 0 && createContext(scope),
           fn instanceof AsyncFunction && createAsyncScope(scope),
           1 === id
             ? createContext(scope)
             : 2 === id
-              ? (setTmp(scope), compileErrorHandler$1(scope))
+              ? (setTmp(scope), compileErrorHandler(scope))
               : 3 === id &&
                 (setTmp(scope),
-                compileErrorHandler$1(scope),
+                compileErrorHandler(scope),
                 createContext(scope)));
     }
     for (let i = 0, handlers = group[1]; i < handlers.length; i++) {
       let handler = handlers[i];
-      compilerState[3](
+      hooks.compileHandler(
         handler[2],
         handler[3],
         prefix + ('/' === handler[1] || '' !== prefix ? '' : handler[1]),
@@ -186,64 +187,74 @@ let AsyncFunction = (async () => {}).constructor,
           scope.slice(),
           '/' === childPrefix ? prefix : prefix + childPrefix,
         );
-  },
-  _ = Symbol.for('@safe-std/error');
-var aot_default = {
-  fetch: ((me, mwc, f1, f2, f3, f4, f5) => {
-    var t = ['text/html', 'application/json'].map((c) => ['Content-Type', c]),
-      [mwh, mwj] = t,
-      [mwoh, mwoj] = t.map((c) => ({ headers: [c] })),
-      [mwn, mwb] = [404, 400].map((s) => new Response(null, { status: s }));
-    return (r) => {
-      let u = r.url,
-        s = u.indexOf('/', 12) + 1,
-        e = u.indexOf('?', s),
-        p = -1 === e ? u.slice(s) : u.slice(s, e);
-      if ('POST' === r.method && 'api' === p) {
-        let c = mwc(r);
-        return (
-          f1(c),
-          (c.id = f2()),
-          (async () => ((c.body = await f4(c)), new Response(f5(c), c)))()
-        );
-      }
-      if ('path' === p) {
-        let c = mwc(r);
-        return f1(c), (c.id = f2()), new Response(f3(c), c);
-      }
-      return mwn;
-    };
+  };
+(() => {
+  let hook = (fn) => (injectExternalDependency(fn), '');
+  (hooks = { compileHandler: hook, compileErrorHandler: hook }),
+    hydrateDependency(main_default, [!1, !1, , '', !1], '');
+})(),
+  ((_$1, _1, _2, _3, _4, _5, _6) => {
+    _$1.push(
+      (() => {
+        var t = ['text/html', 'application/json'].map((c) => [
+            'Content-Type',
+            c,
+          ]),
+          [mwh, mwj] = t,
+          [mwoh, mwoj] = t.map((c) => ({ headers: [c] })),
+          [mwn, mwb] = [404, 400].map((s) => new Response(null, { status: s })),
+          mwc = (r) => ({ status: 200, req: r, headers: [] });
+        return (r) => {
+          let u = r.url,
+            s = u.indexOf('/', 12) + 1,
+            e = u.indexOf('?', s),
+            p = -1 === e ? u.slice(s) : u.slice(s, e);
+          if ('POST' === r.method && 'api' === p) {
+            let c = mwc(r);
+            return (
+              _2(c),
+              (c.id = _3()),
+              (async () => ((c.body = await _5(c)), new Response(_6(c), c)))()
+            );
+          }
+          if ('path' === p) {
+            let c = mwc(r);
+            return _2(c), (c.id = _3()), new Response(_4(c), c);
+          }
+          return mwn;
+        };
+      })(),
+    );
   })(
-    ...((compilerState[0] = {}),
-    (compilerState[1] = []),
-    (compilerState[2] = ''),
-    (compilerState[3] = (fn) => (compilerState[1].push(fn), '')),
-    (compilerState[4] = (fn) => (compilerState[1].push(fn), '')),
-    hydrateDependency(main_default, [!1, !1, , '', !1], ''),
-    [
-      (u) => Array.isArray(u) && u[0] === _,
-      (r) => ({ status: 200, req: r, headers: [] }),
-    ].concat(compilerState[1])),
-  ),
-};
-export { aot_default as default };
+    ...(() => {
+      let n = [compiledDependencies].concat(externalDependencies);
+      return (externalDependencies.length = 0), n;
+    })(),
+  );
+var _1_default = { fetch: getDependency(0) };
+export { _1_default as default };
 ```
 
 ### Hydration
 ```ts
-import { isHydrating } from '@mapl/web/compiler/config';
+import { isHydrating } from 'runtime-compiler/config';
 
 // false while building the output string
 // true while only building dependencies
 // Use this to for minifiedrs to eliminate unused code path in final output
-isHydrating();
+isHydrating;
 ```
 
 ### Compiling external dependencies
 ```ts
-import { injectLocalDependency, localDependency } from '@mapl/web/compiler';
+import { injectDependency, markDependency, getDependency } from 'runtime-compiler';
+import { isHydrating } from 'runtime-compiler/config';
+
+// Better tree shaking
+const hello = isHydrating
+  ? markDependency<() => void>()
+  : injectDependency<() => void>(`() => console.log('hello')`);
 
-const hello = injectLocalDependency<() => void>(`() => console.log('hello')`);
 // After compiler is executed
-localDependency(hello)();
+getDependency(hello)();
 ```

package/compiler/aot.d.ts

@@ -1,3 +1,4 @@
 import type { RouterTag } from "../core/index.js";
-declare const _default: (router: RouterTag) => any[];
+import "../core/context.js";
+declare const _default: (router: RouterTag) => void;
 export default _default;

package/compiler/aot.js

@@ -1 +1 @@
-import{hydrateDependency,externalDependencies,setHooks}from"@mapl/framework";import{isErr}from"@safe-std/error";import createContext from"../core/context.js";import{compiledDeps}from"./index.js";export default router=>{externalDependencies.length=0;let hook=fn=>{externalDependencies.push(fn);return``};setHooks({compileHandler:hook,compileErrorHandler:hook});hydrateDependency(router,[false,false,,``,false],``);return[isErr,createContext,compiledDeps].concat(externalDependencies)};
+import{hydrateDependency,setHooks}from"@mapl/framework";import{injectExternalDependency}from"runtime-compiler";import"../core/context.js";export default router=>{let hook=fn=>{injectExternalDependency(fn);return``};setHooks({compileHandler:hook,compileErrorHandler:hook});hydrateDependency(router,[false,false,,``,false],``)};

package/compiler/jit.d.ts

@@ -1,4 +1,5 @@
 import type { RouterTag } from "../core/index.js";
-export declare const stateToString: () => string;
-export declare const compileToString: (router: RouterTag) => string;
-export declare const compileToHandler: (router: RouterTag) => ((req: Request) => any);
+import { type CompiledDependency } from "runtime-compiler";
+export declare const injectCompiledHandler: (router: RouterTag) => CompiledDependency<(req: Request) => any>;
+export declare const compileToHandler: (router: RouterTag) => Promise<(req: Request) => any>;
+export declare const compileToHandlerSync: (router: RouterTag) => ((req: Request) => any);

package/compiler/jit.js

@@ -1 +1 @@
-import{compileGroup,createArgSet,AsyncFunction,setHooks,externalDependencies,contextInit,setContextInit}from"@mapl/framework";import compile from"@mapl/router/method/compiler";import{countParams}from"@mapl/router/path";import{insertItem}from"@mapl/router/method";import{isErr}from"@safe-std/error";import createContext from"../core/context.js";import{compiledDeps,localDependencies,stateToArgs}from"./index.js";let urlRouter;let paramArgs=createArgSet(new Array(16).fill(0).map((_1,i)=>`q`+i));let compileReturn=(dat,fnAsync,scopeAsync,contextCreated,result)=>{let typ=dat.type;if(typ===`raw`)return`return `+result;fnAsync&&(result=`await `+result);let str=typ==null?`return new Response(`+result+(contextCreated?`,c)`:`)`):contextCreated?`c.headers.push(`+(typ===`json`?`mwj`:`mwh`)+`);return new Response(`+(typ===`json`?`JSON.stringify(`+result+`)`:result)+`,c)`:`return new Response(`+(typ===`json`?`JSON.stringify(`+result+`),mwoj`:result+`,mwoh`)+`)`;return fnAsync&&!scopeAsync?`return (async()=>{`+str+`})()`:str};let compileToState=router=>{urlRouter={};externalDependencies.length=0;setHooks({compileHandler:(fn,dat,path,scope)=>{let call=`f`+externalDependencies.push(fn)+`(`;let paramCount=countParams(path);paramCount>0&&(call+=paramArgs[paramCount]);if(fn.length>paramCount){call+=paramCount===0?`c`:`,c`;if(!scope[1])return contextInit()+compileReturn(dat,fn instanceof AsyncFunction,scope[0],true,call+`)`)}return compileReturn(dat,fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)},compileErrorHandler:(fn,dat,scope)=>{let call=`f`+externalDependencies.push(fn)+`(t`;if(fn.length>1){call+=`,c`;if(!scope[1])return contextInit()+compileReturn(dat,fn instanceof AsyncFunction,scope[0],true,call+`)`)}return compileReturn(dat,fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)},registerCompiled:(method,path,content)=>insertItem(urlRouter,method,path,content)});setContextInit(`let c=mwc(r);`);compileGroup(router,[false,false,,`return mwb`,false],``,``)};export let stateToString=()=>`"use strict";var t=["text/html","application/json"].map(c=>["Content-Type",c]),[mwh,mwj]=t,[mwoh,mwoj]=t.map(c=>({headers:[c]})),[mwn,mwb]=[404,400].map(s=>new Response(null,{status:s}));`+localDependencies()+`return(r)=>{`+compile(urlRouter,`r.method`,`let u=r.url,s=u.indexOf("/",12)+1,e=u.indexOf("?",s),p=e===-1?u.slice(s):u.slice(s,e);`,1)+`return mwn}`;export let compileToString=router=>{compileToState(router);return`(`+stateToArgs()+`)=>{`+stateToString()+`}`};export let compileToHandler=router=>{compileToState(router);return Function(stateToArgs(),stateToString())(isErr,createContext,compiledDeps,...externalDependencies)};
+import{compileGroup,createArgSet,AsyncFunction,setHooks,contextInit,setContextInit}from"@mapl/framework";import compile from"@mapl/router/method/compiler";import{countParams}from"@mapl/router/path";import{insertItem}from"@mapl/router/method";import{getDependency,injectDependency,injectExternalDependency}from"runtime-compiler";import{evaluate,evaluateSync}from"runtime-compiler/jit";let urlRouter;let paramArgs=createArgSet(new Array(16).fill(0).map((_1,i)=>`q`+i));let compileReturn=(dat,fnAsync,scopeAsync,contextCreated,result)=>{let typ=dat.type;if(typ===`raw`)return`return `+result;fnAsync&&(result=`await `+result);let str=typ==null?`return new Response(`+result+(contextCreated?`,c)`:`)`):contextCreated?`c.headers.push(`+(typ===`json`?`mwj`:`mwh`)+`);return new Response(`+(typ===`json`?`JSON.stringify(`+result+`)`:result)+`,c)`:`return new Response(`+(typ===`json`?`JSON.stringify(`+result+`),mwoj`:result+`,mwoh`)+`)`;return fnAsync&&!scopeAsync?`return (async()=>{`+str+`})()`:str};let compileToState=router=>{urlRouter={};setHooks({compileHandler:(fn,dat,path,scope)=>{let call=injectExternalDependency(fn)+`(`;let paramCount=countParams(path);paramCount>0&&(call+=paramArgs[paramCount]);if(fn.length>paramCount){call+=paramCount===0?`c`:`,c`;if(!scope[1])return contextInit+compileReturn(dat,fn instanceof AsyncFunction,scope[0],true,call+`)`)}return compileReturn(dat,fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)},compileErrorHandler:(fn,dat,scope)=>{let call=injectExternalDependency(fn)+`(t`;if(fn.length>1){call+=`,c`;if(!scope[1])return contextInit+compileReturn(dat,fn instanceof AsyncFunction,scope[0],true,call+`)`)}return compileReturn(dat,fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)},registerCompiled:(method,path,content)=>insertItem(urlRouter,method,path,content)});setContextInit(`let c=mwc(r);`);compileGroup(router,[false,false,,`return mwb`,false],``,``)};export let injectCompiledHandler=router=>{compileToState(router);return injectDependency(`(()=>{var t=["text/html","application/json"].map(c=>["Content-Type",c]),[mwh,mwj]=t,[mwoh,mwoj]=t.map(c=>({headers:[c]})),[mwn,mwb]=[404,400].map(s=>new Response(null,{status:s})),mwc=(r)=>({status:200,req:r,headers:[]});return(r)=>{`+compile(urlRouter,`r.method`,`let u=r.url,s=u.indexOf("/",12)+1,e=u.indexOf("?",s),p=e===-1?u.slice(s):u.slice(s,e);`,1)+`return mwn}})()`)};export let compileToHandler=async router=>{let id=injectCompiledHandler(router);await evaluate();return getDependency(id)};export let compileToHandlerSync=router=>{let id=injectCompiledHandler(router);evaluateSync();return getDependency(id)};

package/constants.js

@@ -1 +1 @@
-import{MAPL,CTX,PATH,REQ,URL,PATH_START,PATH_END,TMP}from"@mapl/framework/constants";export*from"@mapl/framework/constants";export let WEB=MAPL+`w`;export let LOCAL_DEPS=WEB+`l`;export let CTX_FN=WEB+`c`;export let CTX_INIT=`let `+CTX+`=`+CTX_FN+`(`+REQ+`);`;export let PARSE_PATH=`let `+URL+`=`+REQ+`.url,`+PATH_START+`=`+URL+`.indexOf("/",12)+1,`+PATH_END+`=`+URL+`.indexOf("?",`+PATH_START+`),`+PATH+`=`+PATH_END+`===-1?`+URL+`.slice(`+PATH_START+`):`+URL+`.slice(`+PATH_START+`,`+PATH_END+`);`;export let CHTML=WEB+`h`;export let CJSON=WEB+`j`;export let OHTML=WEB+`oh`;export let OJSON=WEB+`oj`;export let R404=WEB+`n`;export let R400=WEB+`b`;export let GLOBALS=`var `+TMP+`=["text/html","application/json"].map(c=>["Content-Type",c]),[`+CHTML+`,`+CJSON+`]=`+TMP+`,[`+OHTML+`,`+OJSON+`]=`+TMP+`.map(c=>({headers:[c]})),[`+R404+`,`+R400+`]=[404,400].map(s=>new Response(null,{status:s}));`;
+import{CTX,PATH,REQ,URL,PATH_START,PATH_END,TMP}from"@mapl/framework/constants";export*from"@mapl/framework/constants";export let WEB=`mw`;export let LOCAL_DEPS=WEB+`l`;export let CTX_FN=WEB+`c`;export let CTX_INIT=`let `+CTX+`=`+CTX_FN+`(`+REQ+`);`;export let PARSE_PATH=`let `+URL+`=`+REQ+`.url,`+PATH_START+`=`+URL+`.indexOf("/",12)+1,`+PATH_END+`=`+URL+`.indexOf("?",`+PATH_START+`),`+PATH+`=`+PATH_END+`===-1?`+URL+`.slice(`+PATH_START+`):`+URL+`.slice(`+PATH_START+`,`+PATH_END+`);`;export let CHTML=WEB+`h`;export let CJSON=WEB+`j`;export let OHTML=WEB+`oh`;export let OJSON=WEB+`oj`;export let R404=WEB+`n`;export let R400=WEB+`b`;export let GLOBALS=`var `+TMP+`=["text/html","application/json"].map(c=>["Content-Type",c]),[`+CHTML+`,`+CJSON+`]=`+TMP+`,[`+OHTML+`,`+OJSON+`]=`+TMP+`.map(c=>({headers:[c]})),[`+R404+`,`+R400+`]=[404,400].map(s=>new Response(null,{status:s})),`+CTX_FN+`=(r)=>({status:200,req:r,headers:[]});`;

package/core/context.d.ts

@@ -5,5 +5,3 @@ export interface Context {
 	status?: number;
 	statusText?: string;
 }
-declare const _default: (r: Request) => Context;
-export default _default;

package/core/context.js

@@ -1 +1 @@
-export default r=>({status:200,req:r,headers:[]});
+export{};

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "@mapl/web",
-"version": "0.2.0-alpha.3",
+"version": "0.2.0-alpha.5",
 "description": "A compiled web framework for all runtimes",
 "keywords": ["fast", "lightweight", "cross-runtime", "framework", "web", "backend"],
 "repository": {
@@ -12,28 +12,26 @@
 "main": "./index.js",
 "types": "./index.d.ts",
 "dependencies": {
-"@mapl/framework": "^0.3.7",
+"@mapl/framework": "^0.4.3",
 "@mapl/router": "^0.6.2",
-"@safe-std/error": "^1.0.1"
+"@safe-std/error": "^1.0.1",
+"runtime-compiler": "^1.0.6"
 },
 "optionalDependencies": {
 "secure-headers": "^0.0.6"
 },
 "exports": {
-".": "./index.js",
-"./constants": "./constants.js",
-"./core/utils": "./core/utils.js",
 "./core/middleware": "./core/middleware.js",
-"./utils/cors": "./utils/cors.js",
-"./core": "./core/index.js",
+"./constants": "./constants.js",
 "./core/context": "./core/context.js",
+"./core": "./core/index.js",
+"./utils/secure-headers": "./utils/secure-headers.js",
 "./core/handler": "./core/handler.js",
+"./utils/cors": "./utils/cors.js",
+"./core/utils": "./core/utils.js",
 "./utils/headers": "./utils/headers.js",
-"./compiler/aot": "./compiler/aot.js",
 "./compiler/jit": "./compiler/jit.js",
-"./compiler": "./compiler/index.js",
-"./compiler/aot-loader": "./compiler/aot-loader.js",
-"./utils/secure-headers": "./utils/secure-headers.js",
-"./compiler/config": "./compiler/config.js"
+".": "./index.js",
+"./compiler/aot": "./compiler/aot.js"
 }
 }

package/compiler/aot-loader.d.ts

@@ -1 +0,0 @@
-export {};

package/compiler/aot-loader.js

@@ -1 +0,0 @@
-import{hydrating}from"./config.js";hydrating();

package/compiler/config.d.ts

@@ -1,5 +0,0 @@
-export declare const isHydrating: () => boolean;
-/**
-* @private
-*/
-export declare const hydrating: () => void;

package/compiler/config.js

@@ -1 +0,0 @@
-let hydrateDependency=false;export let isHydrating=()=>hydrateDependency;export let hydrating=()=>{hydrateDependency=true};

package/compiler/index.d.ts

@@ -1,11 +0,0 @@
-export type LocalDependency<T = unknown> = number & [T];
-declare let;
-/**
-* Inject a dependency
-*/
-export declare const injectLocalDependency: <T>(val: string) => LocalDependency<T>;
-/**
-* Get local dependency value
-* @param i
-*/
-export declare const localDependency: <T>(i: LocalDependency<T>) => T;

package/compiler/index.js

@@ -1 +0,0 @@
-import{externalDependencies}from"@mapl/framework";import{isHydrating}from"./config.js";export let compiledDeps=[];let localDeps=``,localDepsCnt=0;export let injectLocalDependency=val=>{if(!isHydrating())localDeps+=`mwl.push(`+val+`);`;return localDepsCnt++};export let localDependencies=()=>localDeps;export let localDependency=i=>compiledDeps[i];export let stateToArgs=()=>{let depsString=`me,mwc,mwl`;for(let i=0;i<externalDependencies.length;i++)depsString+=`,f`+(i+1);return depsString};