lilact 0.21.1 → 0.23.0

package/src/lilact.jsx

@@ -92,7 +92,7 @@ export {transpileJSX, transpilerConfig} from "./jsx";
 export const Lilact = 
 {	
 
-	VERSION: "beta.21",
+	VERSION: "beta.23",
 	
 	// Configuration
 
@@ -125,9 +125,20 @@ export const Lilact =
 
 }
 
+Lilact.default = Lilact;
+
+export default Lilact;
+
+Lilact.importObjectPaths = {
+	"lilact": Lilact,
+	"@emotion/css": Lilact.emotion,
+	"redux": Lilact.redux
+}
+
 globalThis.Lilact = Lilact;
 globalThis.createComponent = Lilact.createComponent;
 globalThis.Fragment = Lilact.Fragment;
+globalThis.require = Lilact.require;
 
 document.addEventListener('DOMContentLoaded', () => {
   Lilact.runScripts();
@@ -144,5 +155,3 @@ if(DEBUG) {
 	console.log(`Copyright(C) 2024-2026 Arash Kazemi <contact.arash.kazemi@gmail.com>`);
 }
 
-export default Lilact;
-

package/src/run.jsx

@@ -32,6 +32,33 @@ import Lilact from './lilact.jsx';
 import { CORE, COMPONENT, LAZY } from "./symbols.jsx"
 
 
+function joinPaths(basePath, relativePath) {
+	const isAbs = relativePath.startsWith("/");
+	const stack = [];
+
+	const parts = (isAbs ? "" : basePath).split("/").filter(Boolean);
+	for (const p of parts) stack.push(p);
+
+	if(!basePath.endsWith("/")) stack.pop();
+
+	const relParts = relativePath.split("/");
+
+	for (const p of relParts) {
+		if (p === "" || p === ".") continue;
+		if (p === "..") {
+			if (stack.length > 0) stack.pop();
+		} else {
+			stack.push(p);
+		}
+	}
+
+	return (isAbs ? "/" : "") + stack.join("/");
+}
+
+// Examples:
+//console.log(joinPaths("a/b/c", "./../d")); // a/b/dfdsfds
+//console.log(joinPaths("a/b/c", "../../d")); // a/d
+
 /** @ignore */
 export const required_scripts = {};
 
@@ -48,18 +75,19 @@ export const required_scripts = {};
 export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 {
 	const mappings = [];
-	const module = {exports: {}};
-	let processed;
-
-
-	required_scripts[path] = { 	
+	const module = { 	
 		mappings,
-		module,
 		is_inline,
 		path,
 		code: jsx,
+		exports: {}
 	};
 
+	let processed;
+
+
+	required_scripts[path] = module;
+
 
 	try {
 		processed = Lilact.transpileJSX( jsx,
@@ -71,6 +99,7 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 			blocks_info: Lilact.blocks_info,
 
 			injectTraceLabels: true,
+			produceCJS: true,
 		} );
 	}
 	catch(e) {
@@ -80,7 +109,7 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 	}
 
 if(DEBUG) {
-		required_scripts[path].processed = processed;
+	required_scripts[path].processed = processed;
 }		
 	
 	processed += "\n//# sourceURL=eval:/" + path;
@@ -106,31 +135,35 @@ if(DEBUG) {
 
 
 /**
- * Loads a jsx script from a path. All scripts can access Lilact namespace as a global object. 
- * 
- * `require` loads synchronously, as it is expected to be loaded on the next instruction.
- * 
- * As running the transpiled scripts rely on `new Function`, it is not possible to use module imports 
- * and exports. So to import you should use `const {useState} = Lilact` convention. And to 
- * export, you should use `module.exports = ...`. `require` returns `module.exports` value
- * so you can import different modules using the convention above.
+ * Loads a jsx script from a path. `require` loads synchronously, as it is expected to be loaded on the next instruction.
  * 
  * If the path is in the format #id, it will query the document for a script element with the given 
  * id and run its contents.
  * 
  * If require is called inside the function given to lazy, it will run async. See `lazy`.
  * 
+ * All required scripts can access Lilact namespace as a global object. 
+ * 
  * @param path - The path to the required file. Must be either absolute path or relative to the current 
- * document’s URL (the page/location that initiated the request).
+ * module or document’s URL (the page/location that initiated the request).
+ * 
+ * @param [forceUpdate] - Force re-run module. By default an imported module is only run once.
+ * 
+ * @param [checkExport] - An array of module properties to be checked upon import. This is used for import error detection.
+ * 
+ * @param [isLazy] - if loading is should be async. Returns a promise if true.
  * 
- * @param forceUpdate - To treat the code as inline. The main difference at the moment is that inline code doesn't include sourcemap.
+ * @param [requirer] - The module that is importing the other module. This is used internally to resolve relative paths.
  * 
  * @returns An array representation of the children.
  */
-export function require(path, forceUpdate)
+export function require(path, {forceUpdate, checkExport, requirer, isLazy})
 {
-	if(required_scripts[path] && !forceUpdate) return required_scripts[path].module.exports;
+
+	if(Lilact.importObjectPaths?.[path]) return Lilact.importObjectPaths[path];
+	if(required_scripts[path] && !forceUpdate) return required_scripts[path].exports;
 	
+
 	if(path[0]==='#') {
 
 		const el = document.getElementById(path);
@@ -140,32 +173,38 @@ export function require(path, forceUpdate)
 		}
 
 	}
-	else if(Lilact?.[LAZY]) {
-		Lilact[LAZY]=false;
-
-		return fetch(path)
-			.then(res => {
-				if (!res.ok) throw new Error(`HTTP ${res.status}`);
-				return res.text();
-			})
-			.then(res => {
-				res = run(res, path, false);
-				// todo: this is for the lazy, so we detect default, should we do it in sync mode too?
-				return res?.default ?? res;
-			})
-			.catch(err => {
-				throw err;
-			});
-	}
 	else {
-		// note: this makes a sync request. this is not advised,
-		// but import should be sync. for an async solution use lazy and suspense.
-
-		const request = new XMLHttpRequest();
-		request.open("GET", path, false);
-		request.send(null);
-		if (request.status === 200) {
-			return run(request.responseText, path, false);
+		if(requirer && requirer.path) {
+			path = joinPaths(requirer.path, path);
+		}
+
+		if(Lilact?.[LAZY] || isLazy) {
+			Lilact[LAZY]=false;
+
+			return fetch(path)
+				.then(res => {
+					if (!res.ok) throw new Error(`HTTP ${res.status}`);
+					return res.text();
+				})
+				.then(res => {
+					res = run(res, path, false);
+					// todo: this is for the lazy, so we detect default to match react behaviour, but should we do it in sync mode too?
+					return res?.default ?? res;
+				})
+				.catch(err => {
+					throw err;
+				});
+		}
+		else {
+			// note: this makes a sync request. this is not advised,
+			// but import should be sync. for an async solution use lazy and suspense.
+
+			const request = new XMLHttpRequest();
+			request.open("GET", path, false);
+			request.send(null);
+			if (request.status === 200) {
+				return run(request.responseText, path, false);
+			}
 		}
 	}
 
@@ -176,7 +215,15 @@ export function require(path, forceUpdate)
 /**
  * Wrapper that enables async, code-split component loading. `lazy` should be used
  * outside the component definintion or it will produce new components on each rerender.
- *
+ * 
+ * Note that in factory function you should use require instead of `import`. Dynamic `import` 
+ * would work, but it will not be wired correctly to the `Lilact` runtime.
+ * 
+ * Example: 
+ * ``` 
+ * const StopWatch = lazy( () => require('./stopwatch.jsx') );
+ * ```
+ * 
  * @param factory - A function with **no arguments** that returns a `Promise`.
  * The promise must resolve to a module whose module.exports.default is a Lilact component
  * or otherwise it will be whatever the module.exports is set to.

package/src/timers.jsx

@@ -28,11 +28,6 @@
 
 */
 
-// note: lilact timers can be used without lilact. uncomment the directive below to
-// get the transpiled version in dist directory.
-//ʔ outputJS('./dist/timers.js');
-
-
 import  { IDX, DUE, REPEAT, CLEARED, INTERVAL, CALLBACK, ARGS } from "./symbols.jsx"
 
 /**

package/src/jsx.addons.js

@@ -1,70 +0,0 @@
-/*
-
-	Lilact
-	Copyright (C) 2024-2026 Arash Kazemi <contact.arash.kazemi@gmail.com>
-	All rights reserved.
-
-	BSD-2-Clause
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions are met:
-
-	* Redistributions of source code must retain the above copyright
-	  notice, this list of conditions and the following disclaimer.
-	* Redistributions in binary form must reproduce the above copyright
-	  notice, this list of conditions and the following disclaimer in the
-	  documentation and/or other materials provided with the distribution.
-
-	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-	ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-	DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-	ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-const TRANSPILER_OUTPUT = Symbol.for("LILACT:TRANSPILER_OUTPUT");
-
-
-export function defineSymbols(ns, defs) {
-
-	if(defs===undefined) {
-		defs=ns;
-		ns='';
-	}
-	else ns+=':';
-
-	const out = [];
-	const lbls = [];
-	if(defs instanceof Array) {
-		if(ns!=='') {
-			if(typeof(ns)!=='string') ns='';
-			for(let d of defs) {
-				lbls.push(d);
-				out.push(`Symbol.for('${ns}${d}')`);
-			}
-		}
-		else {
-			for(const d of defs) {
-				lbls.push(d);
-				out.push(`Symbol()`);
-			}
-		}
-		return `const [${lbls.join(',')}]=[${out.join(',')}];`;
-	}
-}
-
-export const quote = (x)=>`"${String(x).replace(/(["\n])/g, '\\$1')}"`;
-
-
-// note: this directive is used for files that can be used separatly (i.e. timers.jsx)
-// 		 or in case  you want to check the preprocessors output. 
-
-export function outputJS(filepath) {
-	globalThis[TRANSPILER_OUTPUT] = filepath;
-}