@the-w1zard/the-cloud 1.0.2 → 1.0.4

package/dist/hooks/core/use-ref.js

@@ -1,559 +0,0 @@
-import { createHook, } from '#the-cloud';
-import { useEffect, useCallback, } from '#sauron'; // useSignal,
-import * as React from "#sauron";
-export function useRef(initialValue, __sauron_id__ = _sid()) {
-    return createHook('useRef', __sauron_id__, () => {
-        const subscribers = new Set();
-        let current = (initialValue ?? null);
-        let isAttached = false;
-        const notify = () => { subscribers.forEach(fn => fn(current)); };
-        return { value: { current, isAttached, subscribers, notify } };
-    }, (hook) => {
-        const state = hook.value;
-        const get = () => state.current;
-        const set = (value) => {
-            state.current = value;
-            state.isAttached = value !== null;
-            state.notify();
-        };
-        const subscribe = (callback) => {
-            state.subscribers.add(callback);
-            callback(state.current);
-            return () => {
-                state.subscribers.delete(callback);
-            };
-        };
-        const waitForAttach = (timeout) => {
-            return new Promise((resolve, reject) => {
-                if (state.isAttached && state.current !== null) {
-                    return resolve(state.current);
-                }
-                const timeoutId = timeout
-                    ? setTimeout(() => reject(new Error('Ref attach timeout')), timeout)
-                    : null;
-                const unsubscribe = subscribe((value) => {
-                    if (value !== null) {
-                        if (timeoutId)
-                            clearTimeout(timeoutId);
-                        unsubscribe();
-                        resolve(value);
-                    }
-                });
-            });
-        };
-        const toReact = () => ({
-            get current() { return state.current; },
-            set current(value) { set(value); }
-        });
-        const toCallback = () => (instance) => {
-            set(instance);
-        };
-        return {
-            current: state.current,
-            get,
-            set,
-            subscribe,
-            isAttached: state.isAttached,
-            waitForAttach,
-            toReact,
-            toCallback
-        };
-    });
-}
-export function useComposedRefs(...refs) {
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    return useCallback(composeRefs(...refs), refs);
-}
-function setRef(ref, value) {
-    if (ref !== undefined) {
-        ref.set(value);
-    }
-}
-export function composeRefs1(...refs) {
-    return (instance) => {
-        refs.forEach(ref => {
-            if (!ref)
-                return;
-            if (typeof ref === 'function') {
-                ref(instance);
-            }
-            else if ('set' in ref) {
-                ref.set(instance);
-            }
-            else if ('current' in ref) {
-                ref.current = instance;
-            }
-        });
-    };
-}
-export function composeRefs(...refs) {
-    return (node) => {
-        let hasCleanup = false;
-        const cleanups = refs.map((ref) => {
-            const cleanup = setRef(ref, node);
-            if (!hasCleanup && typeof cleanup === 'function') {
-                hasCleanup = true;
-            }
-            return cleanup;
-        });
-        // React <19 will log an error to the console if a callback ref returns a
-        // value. We don't use ref cleanups internally so this will only happen if a
-        // user's ref callback returns a value, which we only expect if they are
-        // using the cleanup functionality added in React 19.
-        if (hasCleanup) {
-            return () => {
-                for (let i = 0; i < cleanups.length; i++) {
-                    const cleanup = cleanups[i];
-                    if (typeof cleanup == 'function') {
-                        cleanup();
-                    }
-                    /**else {
-                      setRef(refs[i], null);
-                    } */
-                }
-            };
-        }
-    };
-}
-export function createRefForwarder(render, options = {}) {
-    return function RefForwardedComponent(props) {
-        const { ref: externalRef, ...rest } = props;
-        const internalRef = useRef();
-        if (options.validate) {
-            internalRef.subscribe((value) => {
-                if (value && !options.validate(value)) {
-                    console.warn('Ref validation failed:', value);
-                }
-            });
-        }
-        if (options.transform) {
-            internalRef.subscribe((value) => {
-                if (value) {
-                    options.transform(value);
-                }
-            });
-        }
-        const composedRef = (instance) => {
-            internalRef.set(instance);
-            if (typeof externalRef === 'function') {
-                externalRef(instance);
-            }
-            else if (externalRef && 'set' in externalRef) {
-                externalRef.set(instance);
-            }
-            else if (externalRef && 'current' in externalRef) {
-                externalRef.current = instance;
-            }
-        };
-        return render(rest, { ...internalRef, set: composedRef });
-    };
-}
-export function useDomRef() {
-    const ref = useRef();
-    const measure = () => {
-        if (!ref.current)
-            return null;
-        return {
-            width: ref.current.offsetWidth,
-            height: ref.current.offsetHeight,
-            top: ref.current.offsetTop,
-            left: ref.current.offsetLeft,
-            bottom: ref.current.offsetTop + ref.current.offsetHeight,
-            right: ref.current.offsetLeft + ref.current.offsetWidth,
-            scrollWidth: ref.current.scrollWidth,
-            scrollHeight: ref.current.scrollHeight,
-            scrollTop: ref.current.scrollTop,
-            scrollLeft: ref.current.scrollLeft
-        };
-    };
-    const focus = (options) => ref.current?.focus(options);
-    const blur = () => ref.current?.blur();
-    const click = () => ref.current?.click();
-    const scrollIntoView = (options) => ref.current?.scrollIntoView(options);
-    return {
-        ...ref,
-        measure,
-        focus,
-        blur,
-        click,
-        scrollIntoView,
-        useMeasure: () => {
-            //  const sig = useSignal(measure());
-            //ref.subscribe(() => { sig.value = measure(); });
-            //return sig;
-        }
-    };
-}
-export function forwardRef(render) {
-    const component = (props) => {
-        const { ref: externalRef, ...rest } = props;
-        const internalRef = useRef();
-        const composedRef = (instance) => {
-            internalRef.set(instance);
-            if (typeof externalRef === 'function')
-                externalRef(instance);
-            else if (externalRef && 'current' in externalRef)
-                externalRef.current = instance;
-            else if (externalRef && 'set' in externalRef)
-                externalRef.set(instance);
-        };
-        return render(rest, composedRef);
-    };
-    return component;
-}
-export function mergeAnyRefs(...refs) {
-    return (instance) => {
-        refs.forEach(ref => {
-            if (!ref)
-                return;
-            if ('set' in ref && typeof ref.set === 'function')
-                ref.set(instance);
-            else if (typeof ref === 'function')
-                ref(instance);
-            else if ('current' in ref)
-                ref.current = instance;
-        });
-    };
-}
-export function useReactRef(ref) {
-    const internalRef = useRef();
-    if (ref) {
-        if (typeof ref === 'function') {
-            internalRef.subscribe((value) => ref(value));
-        }
-        else if (ref && 'current' in ref) {
-            internalRef.subscribe((value) => { ref.current = value; });
-        }
-    }
-    return internalRef;
-}
-export function toReactRef(handle) {
-    return {
-        get current() { return handle.get(); },
-        set current(value) { handle.set(value); }
-    };
-}
-export function mergeForwardRefs(...refs) {
-    return (instance) => {
-        refs.forEach(ref => {
-            if (typeof ref === 'function') {
-                ref(instance);
-            }
-            else if (ref && 'current' in ref) {
-                ref.current = instance;
-            }
-        });
-    };
-}
-export function useForwardedRef(forwardedRef) {
-    // Create internal ref
-    const internalRef = useRef(undefined);
-    useEffect(() => {
-        // Update forwarded ref whenever internal ref changes
-        if (!forwardedRef)
-            return;
-        if (typeof forwardedRef === 'function') {
-            forwardedRef(internalRef.current);
-        }
-        else if (forwardedRef && 'current' in forwardedRef) {
-            forwardedRef.current = internalRef.current;
-        }
-    }, []);
-    return internalRef;
-}
-export function createForwardRef() {
-    return { current: null };
-}
-export function isForwardRefObject(ref) {
-    return ref && typeof ref === 'object' && 'current' in ref;
-}
-export function isForwardRefCallback(ref) {
-    return typeof ref === 'function';
-}
-/**  REF V2
-
-export function useRef2<T = any>(initial?: T, __sauron_id__ = _sid()): RefHandle<T> {
-  return createHook(
-    'useRef',
-    __sauron_id__,
-    (): RefHookState<T> => ({
-      value: initial ?? null,
-      isAttached: false,
-      subscribers: new Set<(value: T) => void>()
-    }),
-    (state) => {
-      const hook = state as RefHookState<T>
-
-      const get = (): T => hook.value
-      const set = (value: T) => {
-        hook.value = value
-        hook.isAttached = value !== null
-        hook.subscribers.forEach(fn => fn(value))
-      }
-      const subscribe = (cb: (value: T) => void) => {
-        hook.subscribers.add(cb)
-        cb(hook.value)
-        return () => hook.subscribers.delete(cb)
-      }
-      const waitForAttach = (timeout?: number): Promise<T> =>
-        new Promise((resolve, reject) => {
-          if (hook.isAttached && hook.value !== null) return resolve(hook.value)
-          const tid = timeout ? setTimeout(() => reject(new Error('Ref attach timeout')), timeout) : null
-          const unsub = subscribe((v) => {
-            if (v !== null) {
-              if (tid) clearTimeout(tid)
-              unsub()
-              resolve(v)
-            }
-          })
-        })
-      const toReact = (): MutableRefObject<T> => ({
-        get current() { return hook.value },
-        set current(v) { set(v) }
-      })
-      const toCallback = (): RefCallback<T> => (v) => set(v)
-
-      return {
-        get current() { return hook.value },
-        set current(v) { set(v) },
-        get isAttached() { return hook.isAttached },
-        get, set, subscribe, waitForAttach, toReact, toCallback
-      }
-    }
-  )
-}
-export function mergeAnyRefs2<T = any>(...refs: Array<AnyRef<T> | undefined>): RefCallback<T> {
-  return (instance: T) => {
-    refs.forEach(ref => {
-      if (!ref) return
-      if ('set' in ref && typeof (ref as any).set === 'function') (ref as RefHandle<T>).set(instance)
-      else if (typeof ref === 'function') ref(instance)
-      else if ('current' in ref) (ref as any).current = instance
-    })
-  }
-}
-export function forwardRef2<T = any, P = {}>(
-  render: (props: P, ref: ForwardedRef<T>) => any
-): ((props: P & { ref?: ForwardedRef<T> }) => any) & { displayName?: string } {
-  const component = (props: P & { ref?: ForwardedRef<T> }) => {
-    const { ref: externalRef, ...rest } = props as any
-    const internalRef = useRef<T>()
-    const composedRef = (instance: T) => {
-      internalRef.set(instance)
-      if (typeof externalRef === 'function') externalRef(instance)
-      else if (externalRef && 'current' in externalRef) externalRef.current = instance
-      else if (externalRef && 'set' in externalRef) externalRef.set(instance)
-    }
-    return render(rest as P, composedRef)
-  }
-  return component
-}
-export function useDomRef2<T extends HTMLElement = HTMLElement>(__sauron_id__ = _sid()) {
-  const ref = useRef<T>(null, __sauron_id__)
-  return {
-    ...ref,
-    measure: () => {
-      if (!ref.current) return null
-      return {
-        width: ref.current.offsetWidth,
-        height: ref.current.offsetHeight,
-        top: ref.current.offsetTop,
-        left: ref.current.offsetLeft,
-        bottom: ref.current.offsetTop + ref.current.offsetHeight,
-        right: ref.current.offsetLeft + ref.current.offsetWidth,
-        scrollWidth: ref.current.scrollWidth,
-        scrollHeight: ref.current.scrollHeight,
-        scrollTop: ref.current.scrollTop,
-        scrollLeft: ref.current.scrollLeft
-      }
-    },
-    focus: (options?: FocusOptions) => ref.current?.focus(options),
-    blur: () => ref.current?.blur(),
-    click: () => ref.current?.click(),
-    scrollIntoView: (options?: ScrollIntoViewOptions) => ref.current?.scrollIntoView(options)
-  }
-}
-export function useReactRef2<T = any>(ref: ForwardedRef<T>): RefHandle<T> {
-  const internalRef = useRef<T>()
-  if (ref) {
-    if (typeof ref === 'function') {
-      internalRef.subscribe((value) => ref(value))
-    } else if (ref && 'current' in ref) {
-      internalRef.subscribe((value) => { ref.current = value })
-    }
-  }
-  return internalRef
-}
-interface RefHandle2<T = any> {
-  current: T
-  get: () => T
-  set: (value: T) => void
-  subscribe: (callback: (value: T) => void) => () => void
-  isAttached: boolean
-  waitForAttach: (timeout?: number) => Promise<T>
-  toReact: () => MutableRefObject<T>
-  toCallback: () => RefCallback<T>
-}
-interface RefForwardingOptions2 {
-  autoAttach?: boolean
-  validate?: (target: any) => boolean
-  transform?: <T, R>(value: T) => R
-}
-
-export function createRefForwarder2<T = any, P = {}>(
-  render: (props: P, ref: RefHandle2<T>) => any,
-  options: RefForwardingOptions2 = {}
-): (props: P & { ref?: RefHandle2<T> | ((instance: T) => void) | { current: T } }) => any {
-  return function RefForwardedComponent(props) {
-    const { ref: externalRef, ...rest } = props as any
-    const internalRef = useRef<T>()
-
-    if (options.validate) {
-      internalRef.subscribe((value) => {
-        if (value && !options.validate!(value)) {
-          console.warn('Ref validation failed:', value)
-        }
-      })
-    }
-
-    if (options.transform) {
-      internalRef.subscribe((value) => {
-        if (value) options.transform!(value)
-      })
-    }
-
-    const composedRef = (instance: T) => {
-      internalRef.set(instance)
-      if (typeof externalRef === 'function') externalRef(instance)
-      else if (externalRef && 'set' in externalRef) externalRef.set(instance)
-      else if (externalRef && 'current' in externalRef) externalRef.current = instance
-    }
-
-    // Fix: Pass both props AND the ref handle to render
-    return render({ ...rest, ref: { ...internalRef, set: composedRef } } as P, internalRef as RefHandle2<T>)
-  }
-}
-export function toReactRef2<T = any>(handle: RefHandle<T>): MutableRefObject<T> {
-  return {
-    get current() { return handle.get() },
-    set current(value: T) { handle.set(value) }
-  }
-}
-export function mergeForwardRefs2<T = any>(
-  ...refs: (FowardRef<T> | undefined)[]
-): (instance: T) => void {
-  return (instance: T) => {
-    refs.forEach(ref => {
-      if (typeof ref === 'function') {
-        ref(instance);
-      } else if (ref && 'current' in ref) {
-        (ref as { current: T }).current = instance;
-      }
-    });
-  };
-}
-export function useForwardedRef2<T = any>(forwardedRef: FowardRef<T>): { current: T } {
-  // Create internal ref
-  const internalRef = useRef<T>(null);
-
-  useEffect(() => {
-    // Update forwarded ref whenever internal ref changes
-    if (!forwardedRef) return;
-
-    if (typeof forwardedRef === 'function') {
-      forwardedRef(internalRef.current);
-    } else if (forwardedRef && 'current' in forwardedRef) {
-      (forwardedRef as { current: T }).current = internalRef.current;
-    }
-  }, []);
-
-  return internalRef;
-}
-export function createForwardRef2<T = any>(): { current: T } {
-  return { current: null };
-}
-export function isForwardRefObject2(ref: any): ref is { current: any } {
-  return ref && typeof ref === 'object' && 'current' in ref;
-}
-export function isForwardRefCallback2(ref: any): ref is (instance: any) => void {
-  return typeof ref === 'function';
-} */
-// Example implementation of how your renderer would handle forwardRef
-/*
-// In your renderer:
-import { FWD_REF_SYMBOL } from '#sauron/forward-ref';
-
-function renderElement(vnode) {
-  if (vnode && vnode.$$typeof === FWD_REF_SYMBOL) {
-    const { __forwardRefRender, ...props } = vnode;
-
-    // Create a ref callback that will be passed to the render function
-    let currentRef = null;
-    const refHandler = (instance) => {
-      currentRef = instance;
-
-      // If props.ref exists, also set that
-      if (props.ref) {
-        if (typeof props.ref === 'function') {
-          props.ref(instance);
-        } else if (props.ref && 'current' in props.ref) {
-          props.ref.current = instance;
-        }
-      }
-    };
-
-    // Call the render function with props and the ref handler
-    return __forwardRefRender(props, refHandler);
-  }
-
-  // Handle regular elements
-  if (typeof vnode === 'object' && vnode !== null && 'ref' in vnode) {
-    const { ref, ...props } = vnode;
-    // Store ref to be applied to DOM element
-    return createElement(vnode.type, { ...props, __ref: ref });
-  }
-
-  // ... rest of rendering logic
-}
-*/
-// Example usage with your component:
-/*
-import { forwardRef, useForwardedRef } from '#sauron/forward-ref';
-
-interface ButtonProps {
-  onClick?: () => void;
-  children?: any;
-  className?: string;
-}
-
-const Button = forwardRef<HTMLButtonElement, ButtonProps>(
-  ({ children, ...props }, ref) => {
-    const buttonRef = useForwardedRef(ref);
-    
-    return (
-      <button
-        {...props}
-        ref={buttonRef}
-        className={`px-4 py-2 bg-blue-500 text-white rounded ${props.className || ''}`}
-      >
-        {children}
-      </button>
-    );
-  }
-);
-
-// In a component:
-function Form() {
-  const submitButtonRef = createForwardRef<HTMLButtonElement>();
-  
-  return (
-    <form>
-      <Button ref={submitButtonRef} onClick={() => console.log('submitted')}>
-        Submit
-      </Button>
-    </form>
-  );
-}
-*/
-const _UNDEFINED_VOID_ONLY = Symbol();
-export const UNDEFINED_VOID_ONLY = _UNDEFINED_VOID_ONLY;

package/dist/hooks/core/use-state2.d.ts

@@ -1 +0,0 @@
-export declare function useState2<T>(initial?: T | (() => T), __sauron_id__?: string): [T, (v: T | ((prev: T) => T)) => void];

package/dist/hooks/core/use-state2.js

@@ -1,15 +0,0 @@
-import { createHook, getCurrentComponent, subscribeToHook, notifyHook } from '#the-cloud';
-export function useState2(initial, __sauron_id__ = _sid()) {
-    return createHook('useState', __sauron_id__, () => ({ value: typeof initial === 'function' ? initial() : initial }), (state, key, notify) => {
-        const setValue = (v) => {
-            const next = typeof v === 'function' ? v(state.value) : v;
-            console.log(`[USESTATE][SETVALUE][KEY]${key}[NEXT]${next}[SAME]${next === state.value}`);
-            if (Object.is(state.value, next))
-                return;
-            state.value = next;
-            notify(key);
-            return next;
-        };
-        return [state.value, setValue];
-    });
-}

package/dist/hooks/deferred_value.d.ts

@@ -1 +0,0 @@
-export declare function useDeferredValue<T>(value: T, __sauron_id__?: string): T;

package/dist/hooks/deferred_value.js

@@ -1,12 +0,0 @@
-import { createHook } from "#tc";
-export function useDeferredValue(value, __sauron_id__ = _sid()) {
-    return createHook('useDeferredValue', __sauron_id__, () => ({ value }), (state, key, notify) => {
-        if (!Object.is(state.value, value)) {
-            queueMicrotask(() => {
-                state.value = value;
-                notify(key);
-            });
-        }
-        return state.value;
-    });
-}

package/dist/hooks/effect.d.ts

@@ -1 +0,0 @@
-export declare function useEffect(effect: (signal?: AbortSignal) => void | (() => void), deps?: A[], __sauron_id__?: string): void;

package/dist/hooks/effect.js

@@ -1,37 +0,0 @@
-export function useEffect(effect, deps, __sauron_id__ = _sid()) {
-    createHook('useEffect', __sauron_id__, () => {
-        const controller = new AbortController();
-        const cleanup = effect(controller.signal);
-        return {
-            value: undefined,
-            deps: deps ?? [],
-            cleanup: () => {
-                controller.abort();
-                if (typeof cleanup === 'function')
-                    cleanup();
-            }
-        };
-    }, (state) => {
-        if (deps === undefined || !_depsEqual(state.deps ?? [], deps)) {
-            state.cleanup?.();
-            const controller = new AbortController();
-            const cleanup = effect(controller.signal);
-            state.deps = deps ?? [];
-            state.cleanup = () => {
-                controller.abort();
-                if (typeof cleanup === 'function')
-                    cleanup();
-            };
-        }
-        return undefined;
-    });
-}
-function _depsEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (!Object.is(a[i], b[i]))
-            return false;
-    }
-    return true;
-}

package/dist/hooks/hooks.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/hooks.js

@@ -1 +0,0 @@
-export {};

package/dist/hooks/impertaive_handle.d.ts

@@ -1,3 +0,0 @@
-export declare function useImperativeHandle<T>(ref: {
-    current: T | null;
-}, init: () => T, deps?: A[], __sauron_id__?: string): void;

package/dist/hooks/impertaive_handle.js

@@ -1,24 +0,0 @@
-import { createHook } from "#tc";
-function _depsEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (!Object.is(a[i], b[i]))
-            return false;
-    }
-    return true;
-}
-export function useImperativeHandle(ref, init, deps, __sauron_id__ = _sid()) {
-    createHook('useImperativeHandle', __sauron_id__, () => {
-        if (ref)
-            ref.current = init();
-        return { value: undefined, deps: deps ?? [] };
-    }, (state) => {
-        if (deps === undefined || !_depsEqual(state.deps ?? [], deps)) {
-            if (ref)
-                ref.current = init();
-            state.deps = deps ?? [];
-        }
-        return undefined;
-    });
-}

package/dist/hooks/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/index.js

@@ -1,4 +0,0 @@
-// Auto-generated index file
-// DO NOT EDIT MANUALLY
-export {};
-// hooks/ui-interactions/index.ts