runtime-compiler 3.0.0 → 3.0.1

package/derive.d.ts

@@ -0,0 +1,59 @@
+import { type Expression, type Value } from "./index.ts";
+/**
+* Derive a value from other expressions.
+* Use in `default` and `build` mode.
+*
+* @example
+* const newValue = derive(
+*   ['Math.random()' as Expression<number>],
+*   (rand) => rand * 10
+* ); // '$[0](Math.random())'
+*
+* // In hydrate mode
+* injectExternal((rand) => rand * 10);
+*/
+export declare const derive: <
+	const Expressions extends Expression<any>[],
+	R
+>(values: Expressions, fn: (...args: { [K in keyof Expressions] : Expressions[K]["~type"] }) => R) => Value<R>;
+/**
+* Derive a value from other expressions.
+* Use in `default` and `build` mode.
+*
+* @example
+* const newValue = deriveAsync(
+*   ['await fetch("http://example.com")' as Expression<Response>],
+*   async (res) => await res.text()
+* ); // 'await $[0](await fetch("http://example.com"))'
+*
+* // In hydrate mode
+* injectExternal((rand) => rand * 10);
+*/
+export declare const deriveAsync: <
+	const Expressions extends Expression<any>[],
+	R
+>(values: Expressions, fn: (...args: { [K in keyof Expressions] : Expressions[K]["~type"] }) => Promise<R>) => Expression<R>;
+/**
+* Describe an injected call.
+*/
+export declare class InjectedCall<
+	const Args extends any[],
+	const R
+> {
+	args: Expression<any>[];
+	fn: (...args: Args) => R;
+	constructor(args: Expression<any>[], fn: (...args: Args) => R);
+}
+/**
+* @param values
+* @param fn
+*/
+export declare const inject: <
+	const Expressions extends Expression<any>[],
+	Args extends any[],
+	R
+>(values: Expressions, fn: (...args: [...{ [K in keyof Expressions] : Expressions[K]["~type"] }, ...Args]) => R) => InjectedCall<Args, R>;
+/**
+* Inject the external function, cache the access to a local dependency and run with provided args.
+*/
+export declare const cacheCall: <R>(fn: (...args: any[]) => R, args: string) => Value<R>;

package/derive.js

@@ -0,0 +1 @@
+import{injectDependency,injectExternal}from"./index.js";export let derive=(e,a)=>injectExternal(a)+`(`+e.join()+`)`;export let deriveAsync=(e,a)=>`await `+injectExternal(a)+`(`+e.join()+`)`;export class InjectedCall{args;fn;constructor(e,i){this.args=e;this.fn=i}}export let inject=(e,i)=>new InjectedCall(e,i);export let cacheCall=(a,o)=>injectDependency(injectExternal(a))+`(`+o+`)`;

package/index.d.ts

@@ -1,26 +1,15 @@
-declare const _01: unique symbol;
-export type Statements = string & {
-	[_01]: 0
+export type Expression<T> = string & {
+	"~type": T
 };
-declare const _02: unique symbol;
-export type Statement = Statements & {
-	[_02]: 0
+export type Value<T> = Expression<T> & {
+	"~value": 0
 };
-declare const _: unique symbol;
-export type Expression<T> = Statement & {
-	[_]: T
+export type Identifier<T> = Value<T> & {
+	"~id": 0
 };
-declare const _11: unique symbol;
-export type Identifier<T> = Expression<T> & {
-	[_11]: 0
-};
-declare const _20: unique symbol;
 export type ExportedDependency<T> = number & {
-	[_20]: 0
+	"~type": T
 };
-export type InferExpression<T extends {
-	[_]: any
-}> = T[typeof _];
 interface InjectDependencyFn {
 	<T>(val: Expression<T>): Identifier<T>;
 	<T>(val: string): Identifier<T>;
@@ -33,56 +22,47 @@ export declare const injectDependency: InjectDependencyFn;
 /**
 * Export a local dependency.
 * Use in `default` and `build` mode.
-* @param name
+* @param value
 */
-export declare const exportDependency: <T>(name: Expression<T>) => ExportedDependency<T>;
+export declare const exportDependency: <T>(value: Expression<T>) => ExportedDependency<T>;
 /**
-* Mark a slot in compiled dependencies.
+* Mark a slot to export a dependency.
 * Use in `hydrate` mode.
 */
 export declare const markExported: <T>() => ExportedDependency<T>;
 /**
-* Get the value of a dependency.
+* Get the value of an exported dependency.
 * @param idx
 */
 export declare const getDependency: <T>(idx: ExportedDependency<T>) => T;
 /**
-* Add extra code after dependency building
-*/
-export declare const addExtraCode: (str: string) => void;
-/**
 * Inject an external dependency.
 */
-export declare const injectExternalDependency: <T>(val: T) => Identifier<T>;
+export declare const injectExternal: <T>(val: T) => Value<T>;
 /**
-* Get external dependency names.
+* Evaluate to statements instead of a function.
 * Use in `default` and `build` mode.
 */
-export declare const externalDependencyNames: () => string;
-/**
-* Equivalent to calling `evaluate`/`evaluateSync` in `default` or `build` mode.
-* Return the args that needs to be passed in.
-* Use in `hydrate` mode.
-*
-* @example
-* (() => {
-*   // Built content
-* })(finishHydration())
-*/
-export declare const hydrate: () => any[];
+export declare const evaluateToStatements: () => string;
 /**
-* Get evaluated code.
-* Use in `default` and `build` mode.
+* Evaluate code to a function.
+* Use in `build` mode.
 */
-export declare const evaluateCode: () => Statements;
+export declare const evaluateToFn: (extraCode: string) => Expression<(...args: any[]) => any>;
 /**
-* Evaluate code to string.
-* Use in `default` and `build` mode.
+* Run evaluated code.
+* Use in `default` mode.
 */
-export declare const evaluateToString: () => Expression<(...args: any[]) => any>;
+export declare const evaluate: (extraCode: string) => any;
 /**
-* Run evaluated code.
-* Use in `default` and `build` mode.
+* Hydrate a built function.
+* Use in `hydrate` mode.
+*
+* @example
+* hydratedCode += `
+*   import { hydrate } from 'runtime-compiler';
+*   const compiled = hydrate(${evaluateToFn(app)});
+* `;
 */
-export declare const evaluate: () => any;
+export declare const hydrate: <T>(compiledFn: (externalDependencies: any[]) => T) => T;
 export {};

package/index.js

@@ -1 +1 @@
-export let compiledDependencies=[];export let externalDependencies=[];export let localDeps=``;let localDepsCnt=0;export let injectDependency=e=>{localDeps+=`,$`+localDepsCnt+`=`+e;return`$`+ localDepsCnt++};export let exportedDeps=``;let exportedDepsCnt=0;export let exportDependency=e=>(exportedDeps+=e+`,`,exportedDepsCnt++);export let markExported=()=>exportedDepsCnt++;export let getDependency=g=>compiledDependencies[g];export let extraCode=``;export let addExtraCode=e=>{extraCode+=e};export let injectExternalDependency=e=>`_`+externalDependencies.push(e);export let externalDependencyNames=()=>{let e=`_,`;for(let _=0;_<externalDependencies.length;_++)e+=`_`+(_+1)+`,`;return e};export let hydrate=()=>[compiledDependencies].concat(externalDependencies);export let evaluateCode=()=>`var $`+localDeps+`;_.push(`+exportedDeps+`);`+extraCode;export let evaluateToString=()=>`(`+externalDependencyNames()+`)=>{`+evaluateCode()+`}`;export let evaluate=()=>{try{return Function(externalDependencyNames(),evaluateCode())(compiledDependencies,...externalDependencies)}finally{localDeps=``;localDepsCnt=0;exportedDeps=``;extraCode=``}};
+let externals=[];let localDeps=``;let localDepsCnt=0;let exportDeps=``;export let injectDependency=e=>{localDeps+=`,$`+localDepsCnt+`=`+e;return`$`+ localDepsCnt++};export let exportDependency=d=>(exportDeps+=`;$[`+externals.length+`]=`+d,externals.push(null)-1);export let markExported=()=>externals.push(null)-1;export let getDependency=d=>externals[d];export let injectExternal=d=>`$[`+(externals.push(d)-1)+`]`;export let evaluateToStatements=()=>localDeps.length===0?exportDeps:`let `+localDeps.slice(1)+exportDeps;export let evaluateToFn=e=>`$=>{var _`+localDeps+exportDeps+e+`}`;export let evaluate=f=>{try{return Function(`$`,`var _`+localDeps+exportDeps+f)(externals)}finally{localDeps=``;localDepsCnt=0;exportDeps=``}};export let hydrate=d=>d(externals);

package/package.json

@@ -1 +1 @@
-{"name":"runtime-compiler","version":"3.0.0","description":"Universal compiler system","keywords":[],"repository":{},"homepage":"","license":"MIT","type":"module","exports":{"./config":"./config/index.js","./config/mode/hydrate":"./config/mode/hydrate.js","./config/loader/build":"./config/loader/build.js","./config/loader/hydrate":"./config/loader/hydrate.js","./config/mode/build":"./config/mode/build.js","./call":"./call.js","./utils":"./utils.js",".":"./index.js","./scope":"./scope.js"}}
+{"name":"runtime-compiler","version":"3.0.1","description":"Universal compiler system","keywords":[],"repository":{},"homepage":"","license":"MIT","type":"module","exports":{".":"./index.js","./config":"./config/index.js","./utils":"./utils.js","./derive":"./derive.js","./config/mode/build":"./config/mode/build.js","./config/loader/build":"./config/loader/build.js","./config/mode/hydrate":"./config/mode/hydrate.js","./config/loader/hydrate":"./config/loader/hydrate.js"}}

package/call.d.ts

@@ -1,23 +0,0 @@
-import type { Identifier, InferExpression } from "./index.ts";
-declare const sym: unique symbol;
-type sym = typeof sym;
-export interface InjectedCall<Deps extends Identifier<any>[]> {
-	[sym]: Deps;
-}
-/**
-* Inject dependency to an fn for later compilation
-*/
-export declare const inject: <
-	const Deps extends Identifier<any>[],
-	const Args extends any[],
-	const Ret
->(deps: Deps, fn: (...args: [...{ [K in keyof Deps] : InferExpression<Deps[K]> }, ...Args]) => Ret) => ((...args: Args) => Ret) & InjectedCall<Deps>;
-interface GetDepsFn {
-	<Deps extends Identifier<any>[]>(fn: InjectedCall<Deps>): Deps;
-	(fn: any): Identifier<any>[] | undefined;
-}
-/**
-* Get fn injected dependency list
-*/
-export declare const getDeps: GetDepsFn;
-export {};

package/call.js

@@ -1 +0,0 @@
-let sym=Symbol();export let inject=(t,n)=>(n[sym]=t,n);export let getDeps=t=>t[sym];

package/scope.d.ts

@@ -1,4 +0,0 @@
-export type Scope = [nextId: number];
-export declare const init: () => Scope;
-export declare const nextId: (scope: Scope) => string;
-export declare const idCount: (scope: Scope) => number;

package/scope.js

@@ -1 +0,0 @@
-export let init=()=>[0];export let nextId=e=>`l`+ e[0]++;export let idCount=e=>e[0];