lilact 0.31.12 → 0.31.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lilact",
-  "version": "0.31.12",
+  "version": "0.31.14",
   "description": "A Little React/JSX Runtime Implementation for Browser",
   "repository": "github:arashkazemi/lilact",
   "homepage": "https://arashkazemi.github.io/lilact/",

package/src/events.jsx

@@ -29,91 +29,86 @@
 */
 
 
+export class SyntheticEvent {
+	constructor(nativeEvent, currentTarget) {
+		this.nativeEvent = nativeEvent;
+		this.type = nativeEvent.type;
+		this.target = nativeEvent.target || nativeEvent.srcElement || null;
+		this.currentTarget = currentTarget || nativeEvent.currentTarget || null;
+		this.timeStamp = nativeEvent.timeStamp ?? Date.now();
+		this.defaultPrevented = !!nativeEvent.defaultPrevented;
+
+		let propagationStopped = false;
+
+		this.isDefaultPrevented = () => this.defaultPrevented;
+		this.isPropagationStopped = () => propagationStopped;
+		this.preventDefault = () => {
+			nativeEvent.preventDefault?.();
+			this.defaultPrevented = true;
+		};
+		this.stopPropagation = () => {
+			nativeEvent.stopPropagation?.();
+			propagationStopped = true;
+		};
+
+		// Modern React doesn't pool events, so persist is a no-op.
+		this.persist = () => {};
+		this.isPersistent = () => true;
+
+		for (
+			let source = nativeEvent;
+			source && source !== Object.prototype;
+			source = Object.getPrototypeOf(source)
+		) {
+			for (const key of Object.getOwnPropertyNames(source)) {
+				if (key === "constructor" || key in this) continue;
+
+				Object.defineProperty(this, key, {
+					configurable: true,
+					enumerable: true,
+					get() {
+						const value = nativeEvent[key];
+						return typeof value === "function"
+							? value.bind(nativeEvent)
+							: value;
+					},
+				});
+			}
+		}
+	}
+}
+
 export function createSyntheticEvent(nativeEvent, currentTarget) {
-  let propagationStopped = false;
-
-  const event = {
-    nativeEvent,
-    type: nativeEvent.type,
-    target: nativeEvent.target || nativeEvent.srcElement || null,
-    currentTarget: currentTarget || nativeEvent.currentTarget || null,
-    timeStamp: nativeEvent.timeStamp ?? Date.now(),
-    defaultPrevented: !!nativeEvent.defaultPrevented,
-
-    isDefaultPrevented() {
-      return event.defaultPrevented;
-    },
-
-    isPropagationStopped() {
-      return propagationStopped;
-    },
-
-    preventDefault() {
-      nativeEvent.preventDefault?.();
-      event.defaultPrevented = true;
-    },
-
-    stopPropagation() {
-      nativeEvent.stopPropagation?.();
-      propagationStopped = true;
-    },
-
-    // Like React 17+ web SyntheticEvents: no pooling, persist is a no-op.
-    persist() {},
-
-    isPersistent() {
-      return true;
-    },
-  };
-
-  // Forward event-specific properties (such as WheelEvent.deltaX/deltaY)
-  // and native methods that are not explicitly defined above.
-  return new Proxy(event, {
-    get(target, property, receiver) {
-      if (Reflect.has(target, property)) {
-        return Reflect.get(target, property, receiver);
-      }
-
-      const value = Reflect.get(nativeEvent, property, nativeEvent);
-      return typeof value === "function" ? value.bind(nativeEvent) : value;
-    },
-
-    has(target, property) {
-      return Reflect.has(target, property) || property in nativeEvent;
-    },
-  });
+	return new SyntheticEvent(nativeEvent, currentTarget);
 }
 
 export function releaseSyntheticEvent(event) {
-  // Clear currentTarget after dispatch, but don't invalidate the event.
-  if (event) event.currentTarget = null;
+	if (event) event.currentTarget = null;
 }
 
 export function wrapListener(fn, opts = {}) {
-  const { stopPropagationOnTrueReturn = false } = opts;
-
-  return function handler(nativeEvent) {
-    const event = createSyntheticEvent(
-      nativeEvent,
-      this || nativeEvent.currentTarget || null
-    );
-
-    try {
-      const result = fn(event);
-
-      if (stopPropagationOnTrueReturn && result === true) {
-        event.stopPropagation();
-      }
-    } finally {
-      releaseSyntheticEvent(event);
-    }
-  };
+	const { stopPropagationOnTrueReturn = false } = opts;
+
+	return function handler(nativeEvent) {
+		const event = createSyntheticEvent(
+			nativeEvent,
+			this || nativeEvent.currentTarget || null
+		);
+
+		try {
+			const result = fn(event);
+			if (stopPropagationOnTrueReturn && result === true) {
+				event.stopPropagation();
+			}
+		} finally {
+			releaseSyntheticEvent(event);
+		}
+	};
 }
 
 export function addWrappedEventListener(target, type, fn, options = {}) {
-  const handler = wrapListener(fn, options);
-
-  target.addEventListener(type, handler, options);
+	const handler = wrapListener(fn, options);
+	target.addEventListener(type, handler, options);
 
-  return () => target.removeEventListener(type, handler, options);
+	return () => target.removeEventListener(type, handler, options);
 }

package/src/expscan.js

@@ -337,17 +337,18 @@ export function processImportExports(node, jsx, meta)
 									continue;
 				}
 				case 'F':{
-									const tp = node.out[i];
-									node.out[i] = null;
+					
 									i++;
-									skip_spaces();
+
+									while(s[i]===' ' || s[i]==='\n' || s[i]==='C') {
+										i++;
+									}
+
 									const name = node.out[i];
-				
-									// node.out[i] = null;
-									// i++;
-									// skip_spaces();				
-				
-									node.out[m.index].cjs = `module.exports.${name} = ${tp} `;
+
+									node.out[m.index].cjs = '';
+									node.out[m.index].appendix_js = `module.exports.${name} = ${name};`;
+
 									continue;
 				}
 				case '*':

package/src/jsx.js

@@ -170,6 +170,8 @@ function parseComment(code, index, container)
 		index++;
 	}
 
+
+
 	raiseError(`Unterminated comment`, b.begin);
 }
 
@@ -997,6 +999,8 @@ export function transpileJSX( jsx, {
 	transpilerConfig.preprocessorDelimiter ??= 'ʔ'; // alt+shift+. on apple abc extended layout  
 	transpilerConfig.injectTraceLabels ??= injectTraceLabels;
 
+	jsx+='\n';
+
 	const eols = scanEOLs(jsx);
 
 	raiseError = ((eols, msg, index)=>{
@@ -1081,6 +1085,7 @@ export function transpileJSX( jsx, {
 	preprocessPragmas(json);
 
 	const flattened_nodes = [];
+	let appendix_js = '\n';
 
 	const codify = (outlen, node, is_attr=false, is_xml=false)=> {
 
@@ -1094,7 +1099,10 @@ export function transpileJSX( jsx, {
 
 		if(node.type==='string') return jsx.substring(node.begin, node.end);
 		if(node.type==='import') return node.cjs;
-		if(node.type==='export') return node.cjs;
+		if(node.type==='export') {
+			if(node.appendix_js) appendix_js+=node.appendix_js;
+			return node.cjs;
+		}
 		if(node.type==='regex') return jsx.substring(node.begin, node.end);
 		if(node.type==='comment') return (discardComments || is_attr)?'':jsx.substring(node.begin, node.end);
 		if(node.type==='directive') return node.value;
@@ -1191,6 +1199,8 @@ export function transpileJSX( jsx, {
 	}
 	out+=codify(out.length, json);
 
+	out+=appendix_js.length>1?appendix_js:'';
+
 	if(injectTraceLabels) {
 		if(transpilerConfig.enableLabelStack) {
 			out += `}catch(e){ if(typeof(e)!=='object') e=new Error(e);e.lilact_trace=[${blocksInfo.counter},e.lilact_trace];throw e}`;

package/src/run.jsx

@@ -137,9 +137,8 @@ function loadModule(path, options = {}) {
 		path = joinPaths(options.requirer.path, path);
 	}
 
-	const loadAsync =
-	Boolean(Lilact[LAZY]) ||
-	Boolean(options.isLazy);
+	const loadAsync = Boolean(Lilact[LAZY]) ||
+										Boolean(options.isLazy);
 
 	const module = getOrCreateModule(path, {});