@mulanjs/mulanjs 1.0.1-dev.20260220155535 → 1.0.1-dev.20260222103836

package/dist/core/hooks.js

@@ -227,3 +227,145 @@ export function muPulse() {
 export function muVault(key, initial, options = {}) {
     return persistent(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
 }
+// --- Next-Gen MulanJS Hooks ---
+/**
+ * muSuspense - The Asynchronous Barrier.
+ * Natively handles async state (loading/data/error) without wrapper components.
+ */
+export function muSuspense(promiseFn) {
+    const state = muState({
+        loading: true,
+        data: null,
+        error: null
+    });
+    // Execute immediately safely
+    promiseFn()
+        .then(res => {
+        state.data = res;
+        state.loading = false;
+    })
+        .catch(err => {
+        state.error = err;
+        state.loading = false;
+    });
+    return state;
+}
+/**
+ * onMuVisibility - The Intersection Observer Hook.
+ * Triggers when the component enters/leaves the viewport.
+ */
+export function onMuVisibility(callback, options = { threshold: 0.1 }) {
+    const instance = getCurrentInstance();
+    // We defer observation to mount phase to ensure DOM exists
+    onMuMount(() => {
+        if (!instance || !instance.container)
+            return;
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach(entry => {
+                callback(entry.isIntersecting);
+            });
+        }, options);
+        observer.observe(instance.container);
+        onMuDestroy(() => {
+            observer.disconnect();
+        });
+    });
+}
+/**
+ * muDebounced - High-performance debouncing built directly into a reactive signal.
+ */
+export function muDebounced(initialValue, delayMs) {
+    const state = muState(initialValue);
+    let timeoutId;
+    return {
+        get value() {
+            return state.value;
+        },
+        set value(newVal) {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                state.value = newVal;
+            }, delayMs);
+        }
+    };
+}
+/**
+ * muThrottled - High-performance throttling built directly into a reactive signal.
+ */
+export function muThrottled(initialValue, delayMs) {
+    const state = muState(initialValue);
+    let lastRan = 0;
+    return {
+        get value() {
+            return state.value;
+        },
+        set value(newVal) {
+            const now = Date.now();
+            if (now - lastRan >= delayMs) {
+                state.value = newVal;
+                lastRan = now;
+            }
+        }
+    };
+}
+/**
+ * onMuPanic - The Iron Fortress Error Boundary.
+ * Catches unhandled exceptions within the component scope.
+ */
+export function onMuPanic(fallbackFn) {
+    const instance = getCurrentInstance();
+    const handler = (event) => {
+        // Broad catch - in a full implementation, we'd inspect the stack trace 
+        // to isolate if it originated from `instance` specifically.
+        // For Mulan 2.0 MVP, we execute the fallback.
+        const error = event instanceof ErrorEvent ? event.error : event.reason;
+        console.error(`[Iron Fortress] Component ${(instance === null || instance === void 0 ? void 0 : instance.$uid) || 'Unknown'} Panic:`, error);
+        fallbackFn(error);
+        // Prevent default browser crash if handled
+        event.preventDefault();
+    };
+    window.addEventListener('error', handler);
+    window.addEventListener('unhandledrejection', handler);
+    onMuDestroy(() => {
+        window.removeEventListener('error', handler);
+        window.removeEventListener('unhandledrejection', handler);
+    });
+}
+/**
+ * muHistory - State with built-in Undo/Redo tracking.
+ */
+export function muHistory(initialValue) {
+    const state = muState(initialValue);
+    // Explicit wrapper object because muState treats bare arrays dynamically
+    const historyTracker = muState({ log: [initialValue] });
+    const pointer = muState(0);
+    const updateValue = (newVal) => {
+        // If we are back in history and make a NEW change, we drop the 'future'
+        if (pointer.value < historyTracker.log.length - 1) {
+            historyTracker.log = historyTracker.log.slice(0, pointer.value + 1);
+        }
+        historyTracker.log.push(newVal);
+        pointer.value = historyTracker.log.length - 1;
+        state.value = newVal;
+    };
+    const undo = () => {
+        if (pointer.value > 0) {
+            pointer.value--;
+            state.value = historyTracker.log[pointer.value];
+        }
+    };
+    const redo = () => {
+        if (pointer.value < historyTracker.log.length - 1) {
+            pointer.value++;
+            state.value = historyTracker.log[pointer.value];
+        }
+    };
+    return {
+        get value() { return state.value; },
+        set value(newVal) { updateValue(newVal); },
+        undo,
+        redo,
+        get past() { return historyTracker.log.slice(0, pointer.value); },
+        get future() { return historyTracker.log.slice(pointer.value + 1); }
+    };
+}

package/dist/mulan.esm.js

@@ -38,18 +38,24 @@ var hooks_namespaceObject = {};
 __webpack_require__.r(hooks_namespaceObject);
 __webpack_require__.d(hooks_namespaceObject, {
   getCurrentInstance: () => (getCurrentInstance),
+  muDebounced: () => (muDebounced),
   muEffect: () => (muEffect),
   muGeom: () => (muGeom),
+  muHistory: () => (muHistory),
   muMemo: () => (muMemo),
   muPulse: () => (muPulse),
   muState: () => (muState),
+  muSuspense: () => (muSuspense),
+  muThrottled: () => (muThrottled),
   muVault: () => (muVault),
   onMuDestroy: () => (onMuDestroy),
   onMuIdle: () => (onMuIdle),
   onMuInit: () => (onMuInit),
   onMuMount: () => (onMuMount),
+  onMuPanic: () => (onMuPanic),
   onMuResume: () => (onMuResume),
   onMuShake: () => (onMuShake),
+  onMuVisibility: () => (onMuVisibility),
   onMuVoice: () => (onMuVoice),
   setCurrentInstance: () => (setCurrentInstance)
 });
@@ -601,6 +607,148 @@ function muPulse() {
 function muVault(key, initial, options = {}) {
     return persistent(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
 }
+// --- Next-Gen MulanJS Hooks ---
+/**
+ * muSuspense - The Asynchronous Barrier.
+ * Natively handles async state (loading/data/error) without wrapper components.
+ */
+function muSuspense(promiseFn) {
+    const state = muState({
+        loading: true,
+        data: null,
+        error: null
+    });
+    // Execute immediately safely
+    promiseFn()
+        .then(res => {
+        state.data = res;
+        state.loading = false;
+    })
+        .catch(err => {
+        state.error = err;
+        state.loading = false;
+    });
+    return state;
+}
+/**
+ * onMuVisibility - The Intersection Observer Hook.
+ * Triggers when the component enters/leaves the viewport.
+ */
+function onMuVisibility(callback, options = { threshold: 0.1 }) {
+    const instance = getCurrentInstance();
+    // We defer observation to mount phase to ensure DOM exists
+    onMuMount(() => {
+        if (!instance || !instance.container)
+            return;
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach(entry => {
+                callback(entry.isIntersecting);
+            });
+        }, options);
+        observer.observe(instance.container);
+        onMuDestroy(() => {
+            observer.disconnect();
+        });
+    });
+}
+/**
+ * muDebounced - High-performance debouncing built directly into a reactive signal.
+ */
+function muDebounced(initialValue, delayMs) {
+    const state = muState(initialValue);
+    let timeoutId;
+    return {
+        get value() {
+            return state.value;
+        },
+        set value(newVal) {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                state.value = newVal;
+            }, delayMs);
+        }
+    };
+}
+/**
+ * muThrottled - High-performance throttling built directly into a reactive signal.
+ */
+function muThrottled(initialValue, delayMs) {
+    const state = muState(initialValue);
+    let lastRan = 0;
+    return {
+        get value() {
+            return state.value;
+        },
+        set value(newVal) {
+            const now = Date.now();
+            if (now - lastRan >= delayMs) {
+                state.value = newVal;
+                lastRan = now;
+            }
+        }
+    };
+}
+/**
+ * onMuPanic - The Iron Fortress Error Boundary.
+ * Catches unhandled exceptions within the component scope.
+ */
+function onMuPanic(fallbackFn) {
+    const instance = getCurrentInstance();
+    const handler = (event) => {
+        // Broad catch - in a full implementation, we'd inspect the stack trace 
+        // to isolate if it originated from `instance` specifically.
+        // For Mulan 2.0 MVP, we execute the fallback.
+        const error = event instanceof ErrorEvent ? event.error : event.reason;
+        console.error(`[Iron Fortress] Component ${(instance === null || instance === void 0 ? void 0 : instance.$uid) || 'Unknown'} Panic:`, error);
+        fallbackFn(error);
+        // Prevent default browser crash if handled
+        event.preventDefault();
+    };
+    window.addEventListener('error', handler);
+    window.addEventListener('unhandledrejection', handler);
+    onMuDestroy(() => {
+        window.removeEventListener('error', handler);
+        window.removeEventListener('unhandledrejection', handler);
+    });
+}
+/**
+ * muHistory - State with built-in Undo/Redo tracking.
+ */
+function muHistory(initialValue) {
+    const state = muState(initialValue);
+    // Explicit wrapper object because muState treats bare arrays dynamically
+    const historyTracker = muState({ log: [initialValue] });
+    const pointer = muState(0);
+    const updateValue = (newVal) => {
+        // If we are back in history and make a NEW change, we drop the 'future'
+        if (pointer.value < historyTracker.log.length - 1) {
+            historyTracker.log = historyTracker.log.slice(0, pointer.value + 1);
+        }
+        historyTracker.log.push(newVal);
+        pointer.value = historyTracker.log.length - 1;
+        state.value = newVal;
+    };
+    const undo = () => {
+        if (pointer.value > 0) {
+            pointer.value--;
+            state.value = historyTracker.log[pointer.value];
+        }
+    };
+    const redo = () => {
+        if (pointer.value < historyTracker.log.length - 1) {
+            pointer.value++;
+            state.value = historyTracker.log[pointer.value];
+        }
+    };
+    return {
+        get value() { return state.value; },
+        set value(newVal) { updateValue(newVal); },
+        undo,
+        redo,
+        get past() { return historyTracker.log.slice(0, pointer.value); },
+        get future() { return historyTracker.log.slice(pointer.value + 1); }
+    };
+}
 
 ;// ./src/core/component.ts
 
@@ -2059,6 +2207,6 @@ if (typeof window !== 'undefined') {
 }
 /* harmony default export */ const src = (Mulan);
 
-export { MuComponent as Component, MuBlochSphereElement, MuComponent, MuInfinity, MuRouter, MuStore, MuRouter as Router, Security, Signal, activeControls, src as default, defineComponent, effect, getCurrentInstance, hydrate, muBurst, muControl, muEffect, muEntangle, muGate, muGeom, muMeasure, muMemo, muParallel, muPulse, muQubit, muRegister, muSearch, muState, muSurge, muSwitch, muTeleport, muVault, onMuDestroy, onMuIdle, onMuInit, onMuMount, onMuResume, onMuShake, onMuVoice, persistent, reactive, ref, render, renderToString, sanitize, setCurrentInstance, useMutation, useQuery };
+export { MuComponent as Component, MuBlochSphereElement, MuComponent, MuInfinity, MuRouter, MuStore, MuRouter as Router, Security, Signal, activeControls, src as default, defineComponent, effect, getCurrentInstance, hydrate, muBurst, muControl, muDebounced, muEffect, muEntangle, muGate, muGeom, muHistory, muMeasure, muMemo, muParallel, muPulse, muQubit, muRegister, muSearch, muState, muSurge, muSuspense, muSwitch, muTeleport, muThrottled, muVault, onMuDestroy, onMuIdle, onMuInit, onMuMount, onMuPanic, onMuResume, onMuShake, onMuVisibility, onMuVoice, persistent, reactive, ref, render, renderToString, sanitize, setCurrentInstance, useMutation, useQuery };
 
 //# sourceMappingURL=mulan.esm.js.map