lilact 0.2.2 → 0.3.0

package/src/hooks.jsx

@@ -407,7 +407,7 @@ export function useReducer(reducer, initialArg, init)
 
 
 
-// todo: very simple implementation. not lilactish! must be modified
+// todo: very simple implementation. and not lilactish at all! must be modified
 
 /**
  * Returns a deferred value that updates later than the provided input.
@@ -417,7 +417,6 @@ export function useReducer(reducer, initialArg, init)
  */
 export function useDeferredValue(value, initialValue)
 {
-
 	const { useEffect, useRef, useState } = Lilact;
 
 	const [deferred, setDeferred] = useState(

package/src/lilact.jsx

@@ -51,7 +51,6 @@ import {ResizablePane} from './pane.jsx';
 
 import {transpileJSX, transpilerConfig} from "./jsx";
 
-//import '../node_modules/@dragdroptouch/drag-drop-touch/dist/drag-drop-touch.esm.min.js';
 
 
 /**
@@ -64,13 +63,13 @@ import {transpileJSX, transpilerConfig} from "./jsx";
 export const Lilact = 
 {	
 
-	VERSION: "beta.0",
+	VERSION: "beta.3",
 	
 	// Configuration
 
 	defaultTransitionTimeout: 300,
 	defaultIsEqual: Object.is, // note: `Lilact.shallowEqual` and `Lilact.deepEqual` are also available, 
-								  // user can set it in your initializer code, and can be changed later too.
+								  					 // user can set it in your initializer code, and can be changed later too.
 	
 	// Units 
 
@@ -82,7 +81,6 @@ export const Lilact =
 	...timers,
 	...misc,
 	...EventWrapper,
-	//...db,
 
 	...router,
 	...accessories,
@@ -92,10 +90,8 @@ export const Lilact =
 	transpileJSX,
 	transpilerConfig,
 
-	// Dependencies ()
-
+	// Dependencies
 	PropTypes,
-	//redux: {...redux, createSlice, createAsyncThunk},
 	redux,
 	emotion,
 

package/src/redux.jsx

@@ -81,68 +81,35 @@ export function useDispatch()
  * @param [equalityFn=(a, b) => a === b] - Determines when the selected value should update.
  * @returns The selected slice of state.
  */
-export function useSelector(selector, equalityFn = (a, b) => a === b) 
-{
-	const store = Lilact.useStore();
-	const latestSelectedRef = Lilact.useRef();
-	const latestSelectorRef = Lilact.useRef();
-	const [, forceRender] = Lilact.useState(0);
-
-	if (!latestSelectorRef.current) {
-		latestSelectorRef.current = selector;
-	}
-	latestSelectorRef.current = selector;
-
-	let selected = selector(store.getState()); // todo: should exception be covered?
+export function useSelector(selector, equalityFn = (a, b) => a === b) {
+  const store = Lilact.useStore();
+  const latestSelected = Lilact.useRef();
+  const selectorRef = Lilact.useRef(selector);
+  selectorRef.current = selector;
 
-	if (latestSelectedRef.current === undefined) {
-		latestSelectedRef.current = selected;
-	}
-
-	Lilact.useLayoutEffect(() => {
-		// keep latestSelectedRef in sync after render (in case selector used props or similar)
-		latestSelectedRef.current = selected;
-	}, [selected]);
+  const [selected, setSelected] = Lilact.useState(() => selector(store.getState()));
 
-	Lilact.useEffect(() => {
+  // Keep ref in sync for the subscription callback
+  latestSelected.current = selected;
 
-		let didUnsubscribe = false;
+  Lilact.useEffect(() => {
+    function checkForUpdates() {
+      const nextSelected = selectorRef.current(store.getState());
+      if (!equalityFn(latestSelected.current, nextSelected)) {
+        latestSelected.current = nextSelected;
+        setSelected(nextSelected);
+      }
+    }
 
-		function checkForUpdates() {
-			if (didUnsubscribe) return;
-			try {
-				const newSelected = latestSelectorRef.current(store.getState());
-				const oldSelected = latestSelectedRef.current;
-				if (!equalityFn(oldSelected, newSelected)) {
-					latestSelectedRef.current = newSelected;
+    const unsubscribe = store.subscribe(checkForUpdates);
 
-					forceRender((n) => n + 1);
-				}
-			} catch (err) {
+    // In case state changed between render and effect
+    checkForUpdates();
 
-ʔ if(DEBUG) {
-				// todo: which is better? cover the error or throw?
+    return unsubscribe;
+  }, [store, equalityFn]);
 
-				// If selector throws during subscription notifications, re-render to surface error
-				// (could instead log or ignore)
-				// throw err;
-				console.warn(err);
-ʔ }
-			}
-		}
-
-		const unsubscribe = store.subscribe(checkForUpdates);
-
-		// run check once in case state changed between render and effect
-		checkForUpdates();
-
-		return () => {
-			didUnsubscribe = true;
-			unsubscribe();
-		};
-	}, [store, equalityFn]);
-
-	return latestSelectedRef.current;
+  return selected;
 }
 
 
@@ -196,3 +163,41 @@ export function connect(mapStateToProps, mapDispatchToProps)
 	};
 }
 
+/**
+ * Creates a root reducer by mapping keys to slice reducers.
+ *
+ * Each slice reducer is called with:
+ *   - the previous slice state at `state[key]` (or `undefined` initially)
+ *   - the dispatched action
+ *
+ * The returned reducer builds the next state object using all reducer keys.
+ * If none of the slice reducers produce a change (reference equality),
+ * the previous `state` object is returned to avoid unnecessary updates.
+ *
+ * @param {object} reducers - An object whose values are reducers.
+ * @returns {function} A root reducer function compatible with your createStore.
+ */
+export function combineReducers(reducers) {
+  const reducerKeys = Object.keys(reducers);
+
+  for (const key of reducerKeys) {
+    if (typeof reducers[key] !== "function") {
+      throw new Error(`combineReducers: reducer for key "${key}" is not a function`);
+    }
+  }
+
+  return function rootReducer(state = {}, action) {
+    let hasChanged = false;
+    const nextState = {};
+
+    for (const key of reducerKeys) {
+      const reducer = reducers[key];
+      const prevSlice = state[key];
+      const nextSlice = reducer(prevSlice, action);
+      nextState[key] = nextSlice;
+      hasChanged = hasChanged || nextSlice !== prevSlice;
+    }
+
+    return hasChanged ? nextState : state;
+  };
+}

package/src/timers.jsx

@@ -38,11 +38,16 @@
 /**
  * Timer helpers for a promise-friendly timer framework.
  *
- * These functions keep the same call signatures as the standard JavaScript timer APIs where applicable (`setTimeout`/`setInterval`/`clearTimeout`/`clearInterval`), but add extra capabilities for promise-friendly control and lifecycle management. This module can “grab” timers and later pause/resume/reset/release them, plus provide promise wrappers like `timeoutPromise` and `animationFramePromise`.
+ * These functions keep the same call signatures as the standard JavaScript timer APIs where applicable 
+ * (`setTimeout`/`setInterval`/`clearTimeout`/`clearInterval`), 
+ * but add extra capabilities for promise-friendly control and lifecycle management. 
+ * 
+ * This module can “grab” timers and later pause/resume/reset/release them, plus provide promise wrappers 
+ * like `timeoutPromise` and `animationFramePromise`.
  *
  * - `setTimeout` / `setInterval`: schedule callbacks (same interface as the built-ins).
  * - `clearTimeout` / `clearInterval`: cancel scheduled timers (same interface as the built-ins).
- * - `grabTimers` / `pauseTimers` / `resumeTimers` / `resetTimers` / `releaseTimers`: manage tracked timers (implementation-dependent behavior).
+ * - `grabTimers` / `pauseTimers` / `resumeTimers` / `resetTimers` / `releaseTimers`: manage tracked timers.
  * - `timeoutPromise` / `animationFramePromise`: promise-based convenience wrappers.
  */
 

package/webpack.config.js

@@ -56,7 +56,7 @@ export default (env, argv) => {
 		optimization: {
 		    concatenateModules: true,      // scope hoisting
 		    moduleIds: 'deterministic',   // smaller stable ids (or 'hashed')
-			minimize: false, //mode === 'production',
+			minimize: true //mode === 'production',
 		},
 		experiments: {    
 			outputModule: true           // enable module output