lilact 0.14.2 → 0.15.1

package/src/redux.jsx

@@ -28,8 +28,10 @@
 
 */
 
+import { createContext, useContext, useRef, useState, useEffect } from './hooks.jsx'
+import { shallowEqual } from './misc.jsx'
 
-ʔ defineSymbols ( "LILACT", [ "CORE" ] ) ʔ
+import { CORE } from "./symbols.jsx"
 
 let ReduxContext;
 
@@ -42,7 +44,7 @@ let ReduxContext;
  */
 export function Provider({ store, children }) 
 {
-	ReduxContext ??= Lilact.createContext(null);
+	ReduxContext ??= createContext(null);
 	return (
 		<ReduxContext.Provider value={store}>{children}</ReduxContext.Provider>
 	);
@@ -55,7 +57,7 @@ export function Provider({ store, children })
  */
 export function useStore() 
 {
-	const store = Lilact.useContext(ReduxContext);
+	const store = useContext(ReduxContext);
 	if (!store) {
 		throw new Error("Could not find Redux store in context. <Provider> is missing.");
 	}
@@ -70,7 +72,7 @@ export function useStore()
  */
 export function useDispatch() 
 {
-	const store = Lilact.useStore();
+	const store = useStore();
 	return store.dispatch;
 }
 
@@ -82,17 +84,17 @@ export function useDispatch()
  * @returns The selected slice of state.
  */
 export function useSelector(selector, equalityFn = (a, b) => a === b) {
-  const store = Lilact.useStore();
-  const latestSelected = Lilact.useRef();
-  const selectorRef = Lilact.useRef(selector);
+  const store = useStore();
+  const latestSelected = useRef();
+  const selectorRef = useRef(selector);
   selectorRef.current = selector;
 
-  const [selected, setSelected] = Lilact.useState(() => selector(store.getState()));
+  const [selected, setSelected] = useState(() => selector(store.getState()));
 
   // Keep ref in sync for the subscription callback
   latestSelected.current = selected;
 
-  Lilact.useEffect(() => {
+  useEffect(() => {
     function checkForUpdates() {
       const nextSelected = selectorRef.current(store.getState());
       if (!equalityFn(latestSelected.current, nextSelected)) {
@@ -127,7 +129,7 @@ export function connect(mapStateToProps, mapDispatchToProps)
 	return function wrapWithConnect(WrappedComponent) {
 
 		function ConnectedComponent(props) {
-			const store = Lilact.useStore();
+			const store = useStore();
 
 			let dispatchProps = { dispatch: store.dispatch };
 
@@ -148,7 +150,7 @@ export function connect(mapStateToProps, mapDispatchToProps)
 				const selector = (state) => mapStateToProps(state, props);
 
 				// todo: is shallowEqual enough?
-				stateProps = Lilact.useSelector(selector, Lilact.shallowEqual) || {};
+				stateProps = useSelector(selector, shallowEqual) || {};
 			}
 
 			const mergedProps = { ...props, ...stateProps, ...dispatchProps };

package/src/router.jsx

@@ -28,7 +28,7 @@
 
 */
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT" ] ) ʔ
+import { CORE, COMPONENT } from "./symbols.jsx"
 
 import {createContext, useContext, useState, useCallback, useEffect} from "./hooks.jsx"
 import {Children} from "./misc.jsx"
@@ -36,8 +36,11 @@ import {Children} from "./misc.jsx"
 const RouterContext = createContext(null);
 const RouteContext = createContext({ params: {} });
 
-// --- HashRouter (as before) ---
-const createURL = (to) => (typeof to === "string" ? to : (to.pathname || "") + (to.search || "") + (to.hash || ""));
+const createURL = (to) =>
+  typeof to === "string" ? to : (to.pathname || "") + (to.search || "") + (to.hash || "");
+
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
 
 /**
  * Hash-based router component that syncs navigation state with the URL hash (#...).
@@ -47,54 +50,90 @@ const createURL = (to) => (typeof to === "string" ? to : (to.pathname || "") + (
  * @param [props.basename=""] - Optional base path prefix applied to all route paths.
  */
 export function HashRouter({ children, basename = "" }) {
-	const readLocation = () => {
-		const raw = window.location.hash || "#/";
-		const full = raw.slice(1);
-		const withoutBase = full.replace(new RegExp(`^${basename}`), "") || "/";
-		const [pathAndSearch, hashPart] = withoutBase.split("#");
-		const [path, search = ""] = pathAndSearch.split("?");
-		return {
-			pathname: path || "/",
-			search: search ? "?" + search : "",
-			hash: hashPart ? "#" + hashPart : "",
-			state: history.state?.__state,
-		};
-	};
-
-	const [location, setLocation] = useState(readLocation);
-	useEffect(() => {
-		const onChange = () => setLocation(readLocation());
-
-		window.addEventListener("hashchange", onChange);
-		window.addEventListener("popstate", onChange);
-
-		// initialize once in case hash/state are already set
-		onChange();
-
-		return () => {
-			window.removeEventListener("hashchange", onChange);
-			window.removeEventListener("popstate", onChange);
-		};
-	}, [basename]);
-
-	const navigate = useCallback((to, { replace = false, state } = {}) => {
-		if (typeof to === "number") {
-			history.go(to);
-			return;
-		}
-
-		const url = createURL(to);
-		const href = "#" + (basename + url);
-
-		if (replace) history.replaceState({ __state: state }, "", href);
-		else history.pushState({ __state: state }, "", href);
-
-		setLocation(readLocation());
-	}, [basename]);
-
-	return <RouterContext.Provider value={{ location, navigate, basename }}>{children}</RouterContext.Provider>;
+  const readLocation = () => {
+    const raw = window.location.hash || "#/";
+    const full = raw.slice(1);
+
+    const baseRe = new RegExp("^" + escapeRegExp(basename));
+    const withoutBase = full.replace(baseRe, "") || "/";
+
+    const [pathAndSearch, hashPart] = withoutBase.split("#");
+    const [path, search = ""] = pathAndSearch.split("?");
+
+    return {
+      pathname: path || "/",
+      search: search ? "?" + search : "",
+      hash: hashPart ? "#" + hashPart : "",
+      state: history.state?.__state,
+    };
+  };
+
+  const [location, setLocation] = useState(readLocation);
+
+  useEffect(() => {
+    const onChange = () => setLocation(readLocation());
+
+    window.addEventListener("hashchange", onChange);
+    window.addEventListener("popstate", onChange);
+
+    // initialize once
+    onChange();
+
+    return () => {
+      window.removeEventListener("hashchange", onChange);
+      window.removeEventListener("popstate", onChange);
+    };
+  }, [basename]);
+
+  const navigate = useCallback((to, { replace = false, state } = {}) => {
+    if (typeof to === "number") {
+      // Wait for the real popstate (don’t rely on synchronous timing)
+      return new Promise((resolve) => {
+        let done = false;
+
+        const cleanup = (fn) => {
+          if (done) return;
+          done = true;
+          window.removeEventListener("popstate", onPop);
+          window.removeEventListener("hashchange", onHash);
+          fn?.();
+          resolve();
+        };
+
+        const onPop = () => cleanup(() => setLocation(readLocation()));
+        const onHash = () => cleanup(() => setLocation(readLocation()));
+
+        window.addEventListener("popstate", onPop, { once: true });
+        window.addEventListener("hashchange", onHash, { once: true });
+
+        // Fallback: in case popstate/hashchange timing is weird in a given browser
+        setTimeout(() => cleanup(() => setLocation(readLocation())), 0);
+
+        history.go(to);
+      });
+    }
+
+    const url = createURL(to);
+    const href = "#" + (basename + url);
+
+    if (replace) {
+      history.replaceState({ __state: state }, "", href);
+    } else {
+      history.pushState({ __state: state }, "", href);
+    }
+
+    // Update immediately for the initiating navigation.
+    setLocation(readLocation());
+  }, [basename]);
+
+  return (
+    <RouterContext.Provider value={{ location, navigate, basename }}>
+      {children}
+    </RouterContext.Provider>
+  );
 }
 
+
 /**
  * Hook that returns the current location object (path, search, hash, and navigation state).
  *

package/src/run.jsx

@@ -27,10 +27,13 @@
 	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
+import Lilact from './lilact.jsx';
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT", "LAZY" ] ) ʔ
+import { CORE, COMPONENT, LAZY } from "./symbols.jsx"
 
-import Lilact from './lilact.jsx';
+
+/** @ignore */
+export const required_scripts = {};
 
 
 /**
@@ -49,7 +52,7 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 	let processed;
 
 
-	Lilact.required_scripts[path] = { 	
+	required_scripts[path] = { 	
 		mappings,
 		module,
 		is_inline,
@@ -76,9 +79,9 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 		throw e;
 	}
 
-ʔ if(DEBUG) {
-		Lilact.required_scripts[path].processed = processed;
-ʔ }		
+if(DEBUG) {
+		required_scripts[path].processed = processed;
+}		
 	
 	processed += "\n//# sourceURL=eval:/" + path;
 
@@ -105,11 +108,11 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 /**
  * Loads a jsx script from a path. All scripts can access Lilact namespace as a global object. 
  * 
- * `Lilact.require` loads synchronously, as it is expected to be loaded on the next instruction.
+ * `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 = ...`. `Lilact.require` returns `module.exports` value
+ * export, you should use `module.exports = ...`. `require` returns `module.exports` value
  * so you can import different modules using the convention above.
  * 
  * If the path is in the format #id, it will query the document for a script element with the given 
@@ -126,14 +129,14 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
  */
 export function require(path, forceUpdate)
 {
-	if(Lilact.required_scripts[path] && !forceUpdate) return Lilact.required_scripts[path].module.exports;
+	if(required_scripts[path] && !forceUpdate) return required_scripts[path].module.exports;
 	
 	if(path[0]==='#') {
 
 		const el = document.getElementById(path);
 
 		if(el) {
-			return Lilact.run(el.innerText, path);
+			return run(el.innerText, path);
 		}
 
 	}
@@ -146,7 +149,7 @@ export function require(path, forceUpdate)
 				return res.text();
 			})
 			.then(res => {
-				res = Lilact.run(res, path, false);
+				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;
 			})
@@ -162,7 +165,7 @@ export function require(path, forceUpdate)
 		request.open("GET", path, false);
 		request.send(null);
 		if (request.status === 200) {
-			return Lilact.run(request.responseText, path, false);
+			return run(request.responseText, path, false);
 		}
 	}
 
@@ -230,8 +233,8 @@ function scanScriptTagsWithType() {
  * Scans the whole documents and runs all the script elements with type `text/jsx`.
  * It is automatically attached to document.onload when Lilact is loaded.
  * 
- * If element src is set, it will be loaded via `Lilact.require`.
- * If element has inner content, it will be executed via `Lilact.run`.
+ * If element src is set, it will be loaded via `require`.
+ * If element has inner content, it will be executed via `run`.
  * 
  * If both are present, first the src is loaded and then the inner content is executed.
  *
@@ -244,8 +247,8 @@ export function runScripts()
 	const scripts = scanScriptTagsWithType();
 
 	for(const s of scripts) {
-		if(s.src) Lilact.require(s.src);
-		if(s.content) Lilact.run(s.content);
+		if(s.src) require(s.src);
+		if(s.content) run(s.content);
 	}
 }
 

package/src/symbols.jsx

@@ -0,0 +1,65 @@
+/*
+
+	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.
+
+*/
+
+
+export const [ 	
+				CORE,
+				COMPONENT,
+				TEXT,
+				IS_ZOMBIE,
+				IDX,
+				CHILD_CLASS_ADDENDUM,
+				MEMOIZED,
+				LAZY,
+
+				DUE,
+				REPEAT,
+				CLEARED,
+				INTERVAL,
+				CALLBACK,
+				ARGS 
+			] = 
+			[
+				Symbol.for('LILACT:CORE'),
+				Symbol.for('LILACT:COMPONENT'),
+				Symbol.for('LILACT:TEXT'),
+				Symbol.for('LILACT:IS_ZOMBIE'),
+				Symbol.for('LILACT:IDX'),
+				Symbol.for('LILACT:CHILD_CLASS_ADDENDUM'),
+				Symbol.for('LILACT:MEMOIZED'),
+				Symbol.for('LILACT:LAZY'),
+
+				Symbol.for('LILACT:TIMERS:DUE'),
+				Symbol.for('LILACT:TIMERS:REPEAT'),
+				Symbol.for('LILACT:TIMERS:CLEARED'),
+				Symbol.for('LILACT:TIMERS:INTERVAL'),
+				Symbol.for('LILACT:TIMERS:CALLBACK'),
+				Symbol.for('LILACT:TIMERS:ARGS')
+			];

package/src/timers.jsx

@@ -33,7 +33,7 @@
 //ʔ outputJS('./dist/timers.js');
 
 
-ʔ defineSymbols("LILACT:TIMERS", ["CORE", "IDX", "DUE", "REPEAT", "CLEARED", "INTERVAL", "CALLBACK", "ARGS"] ) ʔ
+import  { IDX, DUE, REPEAT, CLEARED, INTERVAL, CALLBACK, ARGS } from "./symbols.jsx"
 
 /**
  * Timer helpers for a promise-friendly timer framework.
@@ -254,10 +254,10 @@ export function clearInterval(id)
  */
 export function grabTimers()
 {
-	globalThis.setTimeout = this.setTimeout;
-	globalThis.setInterval = this.setInterval;
-	globalThis.clearTimeout = this.clearTimeout;
-	globalThis.clearInterval = this.clearInterval;
+	globalThis.setTimeout = Lilact.setTimeout;
+	globalThis.setInterval = Lilact.setInterval;
+	globalThis.clearTimeout = Lilact.clearTimeout;
+	globalThis.clearInterval = Lilact.clearInterval;
 }
 
 /**
@@ -277,7 +277,7 @@ export function releaseTimers()
  * @param {number} duration - Delay in milliseconds.
  * @returns {Promise} Promise that resolves after the delay.
  */
-export function timeoutPromise(duration=0, timerSource=this) 
+export function timeoutPromise(duration=0, timerSource=Lilact) 
 {	
 	let id, resolve, reject;
 

package/src/transition.jsx

@@ -27,8 +27,13 @@
 	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
+import Lilact from './lilact.jsx';
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT", "CHILD_CLASS_ADDENDUM" ] ) ʔ
+import { setTimeout, clearTimeout } from "./timers.jsx"
+import { Children } from "./misc.jsx"
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "./hooks.jsx"
+
+import { CORE, COMPONENT, CHILD_CLASS_ADDENDUM } from "./symbols.jsx"
 
 /* States */
 const UNMOUNTED = "unmounted";
@@ -37,9 +42,6 @@ const ENTERING =  "entering";
 const ENTERED =   "entered";
 const EXITING =   "exiting";
 
-import { setTimeout, clearTimeout} from "./timers.jsx"
-import { Children } from "./misc.jsx"
-import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "./hooks.jsx"
 
 /**
  * Transition component that manages enter/exit lifecycle and calls callbacks based on state changes.

package/webpack.config.js

@@ -34,8 +34,7 @@ import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
 
 import fs from 'fs';
-import 'webpack';
-
+import webpack from 'webpack';
 
 
 export default (env, argv) => {
@@ -118,7 +117,12 @@ export default (env, argv) => {
 				}
 			]
 		},
-		plugins: [{
+		plugins: [
+			new webpack.DefinePlugin({
+		        "DEBUG": mode==='development'
+		      }),
+			
+			{
 			apply: (compiler) => {
 				compiler.hooks.done.tap('license-plugin', (compilation) => {
 					fs.readFile('./dist/' + filename, 'utf8', function(err, jssc) {