@cleanweb/oore 2.0.0-alpha.34 → 2.0.0-alpha.36

package/build/_cjs/slots/types.d.ts

@@ -1,128 +0,0 @@
-import type { ReactElement, ReactNode, ComponentType, JSX } from 'react';
-/** @todo ComponentType force children to be ReactNode, but custom components can have any children type. */
-type JSXTagLike = string | keyof JSX.IntrinsicElements | ComponentType<any>;
-/** This fixes overly narrow T type used by React's ComponentProps type. */
-export type ComponentProps<T extends JSXTagLike> = (T extends ComponentType<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : {});
-export type TSlotName = keyof any;
-export type TSlotAlias = keyof any;
-/**
- * A map of slot aliases to actual {@link SlotComponent}s.
- *
- * The `useSlots` hook will create a corresponding key for
- * each alias in this record to hold any `ReactNode`s rendered for that slot.
- */
-export type TSlotsRecord<TKey extends TSlotAlias = TSlotAlias> = {
-    [Key in TKey]: SlotComponent<string | ComponentType<any>>;
-};
-export type DisplayNamedComponent<TComponent extends ComponentType<any> = ComponentType<any>, TName extends string = string> = TComponent & {
-    displayName: TName;
-};
-interface ISlotConfig<TName> {
-    slotName?: TName;
-}
-/**
- * A child component used to insert content into a specific slot in the parent component.
- * This can either be a string, or a React component with a `slotName` property.
- *
- * > `displayName` is no longer supported as a fallback for `slotName`.
- *
- * ### Strings
- * For strings, they are treated by React a native tags. This lets you use custom strings
- * as if you are rendering a custom Web Component, or simply handle specific HTML tags in a specific way.
- *
- * If using a custom string, you will want to handle it in the parent component by simply forwarding the slot's
- * props to an actual element of your choice.
- *
- * So consumers may pass the following as `children`.
- * ```jsx
- * <option-slot>Click</option-slot>
- * ```
- * and you can map that to
- * ```jsx
- * <button
- *     {...slotNodes.Option[0].props}
- *     type="button"
- * />
- * ```
- *
- * ### React Components
- * For slot components that are actual React components, the parent can simply
- * render the slot node directly.
- *
- * So consumers may pass the following as `children`.
- * ```jsx
- * <Parent.Slots.Content>
- *     Some awesome content.
- * </Parent.Slots.Content>
- * ```
- * and you can map that to
- * ```jsx
- * return <>
- *     <h1>Title</h1>
- *     {slotNodes.Content}
- *     <footer>Powered by oore</footer>
- * </>
- * ```
- *
- * This means `Parent.Slots.Content` must be defined as a proper React component
- * and is solely responsible for doing something with the `"Some awesome content."`
- * which was passed into it as children.
- *
- * This is unlike the string version where the parent component
- * extracts the props passed to the slot and handles
- * what the slot actually renders.
- */
-export type SlotComponent<TComponent extends JSXTagLike = ComponentType<any>, TName extends TSlotName = TSlotName> = (TComponent extends string ? TComponent : TComponent & ISlotConfig<TName>);
-/**
- * A parent component which accepts content that can be grouped into predefined slots.
- * By convention, it should have a `slots` property which is a {@link TSlotsRecord}.
- *
- * This allows consumers access the predefined slot components
- * directly from the parent component itself,
- * through an alias that is easy to remember.
- */
-export type SlottedComponent<TOwner extends object = ComponentType<any>, TSlots extends TSlotsRecord = TSlotsRecord> = TOwner & {
-    Slots: TSlots;
-    requiredSlotAliases?: Array<keyof TSlots>;
-};
-export type TypedNode<P, T extends JSXTagLike> = Omit<ReactElement<P>, 'type'> & {
-    type: T;
-};
-export type TSlotNode<TSlotted extends SlottedComponent, Key extends keyof TSlotted['Slots'] = keyof TSlotted['Slots']> = (TypedNode<ComponentProps<TSlotted['Slots'][Key]>, TSlotted['Slots'][Key]>);
-/**
- * A record of slot aliases mapped to the corresponding `ReactNode`(s)
- * to be rendered for that slot.
- */
-export type TSlotNodes<TSlotted extends SlottedComponent> = {
-    [Key in keyof TSlotted['Slots']]?: Array<TSlotNode<TSlotted, Key>>;
-};
-export type TUseSlotsResult<TSlotted extends SlottedComponent> = Readonly<[
-    /**
-     * A record of slot aliases to their corresponding React nodes.
-     * Each alias maps to an array of one or more React nodes that were passed
-     * as children for that slot.
-     *
-     * If a slot was not rendered in `children`, it's alias will be `undefined` in this object.
-     */
-    slotNodes: TSlotNodes<TSlotted>,
-    /**
-     * Valid React nodes passed as children which did not match any of the
-     * predefined slots.
-     */
-    unmatchedChildren: ReactNode[],
-    /**
-     * Items included in `children` which are not valid React nodes.
-     */
-    invalidChildren: any[]
-]>;
-export interface IUseSlots {
-    <TSlotted extends SlottedComponent>(
-    /**
-     * Your component's `children` prop.
-     * The nodes it contains will be categorized and
-     * grouped according to the predefined {@link slotComponents}.
-     */
-    children: ReactNode, Caller: TSlotted): TUseSlotsResult<TSlotted>;
-}
-export type PotentialSlotComponent = string | SlotComponent | ComponentType<any>;
-export {};

package/build/_cjs/slots/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/build/helpers/debounce/index.d.ts

@@ -1,55 +0,0 @@
-interface IDebouncedFunction<TFunc extends AnyFunction> {
-    (...args: Parameters<TFunc>): Promise<ReturnType<TFunc>>;
-    /**
-     * Called internally to trigger the callback with the most recent args
-     * after the delay expires. Can be used to manually trigger the callback
-     * before the normal delay time. If no pending call exists, flush() becomes a no-op.
-     */
-    flush: (isEager?: true) => void;
-}
-export interface IDelayConfig {
-    /**
-     * A non-zero delay in milliseconds.
-     * @default 0
-     */
-    delay?: number;
-    /**
-     * The 'last-call' value specifies that the timer should be applied from the time of the most recent call.
-     * That means each new call while a delay is active will reset the timer, thereby extending the delay.
-     * In other words, it is a "time after inactivity" delay.
-     * Specifying 'first-call' instead will make it use a "time after initial call" delay strategy.
-     */
-    anchor?: 'first-call' | 'last-call';
-    /**
-     * Controls eager execution behavior:
-     * - `false`: Initial call waits for the delay period before executing.
-     * - `'no-queue'`: Initial call fires immediately. Subsequent calls during the delay period
-     *   are skipped and return the promise from the initial call. Ideal for preventing
-     *   duplicate actions like clicking a download button twice.
-     * - `'with-queue'`: Initial call fires immediately. After the initial flush, the promise
-     *   is discarded. The next call during the delay period creates a new workorder that will
-     *   be maintained until the next flush. Ideal for debounced search inputs and similar use cases.
-     * @default 'with-queue'
-     */
-    eager?: false | 'no-queue' | 'with-queue';
-}
-interface IDebounce {
-    <TFunc extends AnyFunction>(callback: TFunc, delayConfigArg?: number | IDelayConfig): IDebouncedFunction<TFunc>;
-}
-/**
- * Wraps the provided function with a debounce.
- *
- * Behavior during the delay period depends on the `eager` configuration:
- * - `eager: false`: All calls wait for the delay. New calls overwrite the existing call.
- * - `eager: 'no-queue'`: First call fires immediately. Subsequent calls during the delay
- *   period are skipped and return the same promise as the initial call.
- * - `eager: 'with-queue'` (default): First call fires immediately. After the flush, the next call
- *   creates a new workorder that will be fired after the delay. New calls overwrite queued args.
- *
- * Once the timer expires, the most recent call is fired.
- *
- * Note: Returned promises may resolve with values from calls made with
- * different arguments. Avoid using this for functions where argument-specific results matter.
- */
-export declare const debounce: IDebounce;
-export {};

package/build/helpers/debounce/index.js

@@ -1,107 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/**
- * Wraps the provided function with a debounce.
- *
- * Behavior during the delay period depends on the `eager` configuration:
- * - `eager: false`: All calls wait for the delay. New calls overwrite the existing call.
- * - `eager: 'no-queue'`: First call fires immediately. Subsequent calls during the delay
- *   period are skipped and return the same promise as the initial call.
- * - `eager: 'with-queue'` (default): First call fires immediately. After the flush, the next call
- *   creates a new workorder that will be fired after the delay. New calls overwrite queued args.
- *
- * Once the timer expires, the most recent call is fired.
- *
- * Note: Returned promises may resolve with values from calls made with
- * different arguments. Avoid using this for functions where argument-specific results matter.
- */
-export const debounce = (...init) => {
-    const [callback, delayArg] = init;
-    const delayConfig = {
-        delay: 1000,
-        anchor: 'first-call',
-        eager: 'with-queue',
-    };
-    if (typeof delayArg === 'number') {
-        delayConfig.delay = delayArg || 1000;
-    }
-    else if (delayArg) {
-        for (const _key in delayArg) {
-            const key = _key;
-            if (delayArg[key] !== undefined) {
-                // @ts-expect-error
-                delayConfig[key] = delayArg[key];
-            }
-        }
-    }
-    let nextCall = null;
-    const debouncedFunction = (...args) => {
-        let currentWork;
-        if (nextCall) {
-            if (delayConfig.eager !== 'no-queue') {
-                nextCall = Object.assign(Object.assign({}, nextCall), { args, work: nextCall.work || Promise.withResolvers() });
-            }
-            currentWork = nextCall.work;
-            if (delayConfig.anchor === 'last-call') {
-                clearTimeout(nextCall.timeout);
-                nextCall.timeout = setTimeout(debouncedFunction.flush, delayConfig.delay);
-            }
-        }
-        else {
-            // No active delay, create new call
-            nextCall = {
-                args,
-                timeout: setTimeout(debouncedFunction.flush, delayConfig.delay),
-                work: Promise.withResolvers(),
-            };
-            currentWork = nextCall.work;
-            // Fire immediately if eager mode is enabled (no-queue or with-queue)
-            if (delayConfig.eager !== false) {
-                debouncedFunction.flush(true);
-            }
-        }
-        if (!currentWork) {
-            throw new Error('[debounce] `currentWork` was not initialized.');
-        }
-        return currentWork.promise;
-    };
-    debouncedFunction.flush = (isEager) => {
-        if (!(nextCall === null || nextCall === void 0 ? void 0 : nextCall.args)) {
-            nextCall = null;
-            // console.log('Queue is empty. Nothing to flush.');
-            return;
-        }
-        // Capture queue values.
-        const { resolve, reject } = nextCall.work || {};
-        const args = nextCall.args;
-        // Clear the queue for new debounced calls.
-        if (isEager) {
-            delete nextCall.args;
-            if (delayConfig.eager === 'with-queue') {
-                delete nextCall.work;
-            }
-        }
-        else {
-            nextCall = null;
-        }
-        // Execute the pending call.
-        (() => __awaiter(void 0, void 0, void 0, function* () {
-            try {
-                // const result = (await callback(...args)) ?? {};
-                // result.__debounceFlushedWithArgs = args;
-                resolve === null || resolve === void 0 ? void 0 : resolve(yield callback(...args));
-            }
-            catch (reason) {
-                reject === null || reject === void 0 ? void 0 : reject(reason);
-            }
-        }))();
-    };
-    return debouncedFunction;
-};

package/build/helpers/debounce/react-state.d.ts

@@ -1,14 +0,0 @@
-import type { SetStateAction } from 'react';
-import { debounce } from './index.js';
-type TDebounceConfig = Exclude<Parameters<typeof debounce>[1], number>;
-type TDelayConfig = number | TDebounceConfig & {
-    staging?: boolean;
-};
-export declare function useDebouncedState<T extends any>(init: T, config: TDelayConfig): readonly [T, {
-    (value: SetStateAction<T>): void;
-    flush: (isEager?: true) => void;
-    pause(): void;
-    resume(): void;
-    paused: boolean;
-}, T];
-export {};

package/build/helpers/debounce/react-state.js

@@ -1,29 +0,0 @@
-import { useCallback, useMemo, useState } from 'react';
-import { debounce } from './index.js';
-export function useDebouncedState(init, config) {
-    const [debouncedValue, setDebouncedValue] = useState(init);
-    const [stagedValue, setStagedValue] = useState(init);
-    const [paused, setPaused] = useState(false);
-    const enableStaging = typeof config === 'object' && config.staging === true;
-    const debounceArgs = [setDebouncedValue, config];
-    const debouncedSetter = useCallback(debounce(...debounceArgs), debounceArgs);
-    const setter = useMemo(() => {
-        const _setter = (value) => {
-            if (enableStaging) {
-                setStagedValue(value);
-            }
-            if (paused) {
-                console.warn('[useDebouncedState] Skipping debounced state update. Updates were paused with `setter.pause()`. Call `setter.play()` to resume.');
-            }
-            else
-                debouncedSetter(value);
-        };
-        _setter.flush = debouncedSetter.flush;
-        _setter.pause = () => setPaused(true);
-        _setter.resume = () => setPaused(false);
-        _setter.paused = paused;
-        return _setter;
-    }, [enableStaging, debouncedSetter]);
-    setter.paused = paused;
-    return [debouncedValue, setter, stagedValue];
-}

package/build/helpers/object-gate.d.ts

@@ -1,74 +0,0 @@
-type TRecord = Record<keyof any, any>;
-declare namespace _ObjectGate {
-    /** Configure property access for a proxy object. */
-    interface IGateConfig<TSource extends TRecord> {
-        /**
-         * The keys to be exposed for read access through the proxy.
-         * Defaults to [`Reflect.ownKeys(source)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/ownKeys) —
-         * so if omitted, all ["_own properties_"](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Enumerability_and_ownership_of_properties)
-         * present on the source at
-         * instantiation time will be exposed for read access through the proxy.
-         */
-        getters?: Readonly<Array<keyof TSource>>;
-        /**
-         * Keys that should definitely be omitted from read access,
-         * even if they are present in {@link getters}.
-         * @default [] - Empty array.
-         */
-        gettersExclude?: Readonly<Array<keyof TSource>>;
-        /**
-         * The keys to be exposed for write access through the proxy.
-         * This defaults to an empty array, so if omitted, none of the gated
-         * properties will be writeable.
-         * @default [] - Empty array.
-         */
-        setters?: Readonly<Array<keyof TSource> | true>;
-        /**
-         * Keys that should definitely be omitted from write access,
-         * even if they are present in {@link setters}.
-         * @default [] - Empty array.
-         */
-        settersExclude?: Readonly<Array<keyof TSource>>;
-    }
-    type Params<TSource extends TRecord> = [
-        /**
-         * The target object, where the actual values are stored.
-         * Keys on the created gate object will use JavaScript getters to return
-         * the real-time value of the same key from this source object.
-         */
-        source: TSource,
-        /** @see {@link IGateConfig} */
-        config?: Readonly<IGateConfig<TSource>>
-    ];
-    class Gate<TSource extends TRecord> {
-        constructor(...params: Params<TSource>);
-    }
-    interface IConstructor {
-        new <TOutput extends Partial<TSource>, TSource extends TRecord>(...params: _ObjectGate.Params<TSource>): TOutput;
-    }
-}
-/**
- * Creates a new object that acts as a real-time proxy
- * for the {@link _ObjectGate.Params | `source`} object.
- * This lets you prevent access to some properties, effectively making them private,
- * while selectively exposing access to only the properties you specify
- * in the {@link _ObjectGate.IGateConfig.getters | `getters`} config option.
- *
- * The exposed properties are read-only by default,
- * exposing only a [getter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description)
- * with no corresponding [setter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set#description).
- *
- * The {@link _ObjectGate.Params | `config`} argument also lets you selectively allow
- * write access to specific properties through the
- * {@link _ObjectGate.IGateConfig.setters | `setters`} config option.
- *
- * Unlike [`structuredClone`](https://developer.mozilla.org/docs/Web/API/Window/structuredClone)
- * this doesn't return a _copy_ of the `source` object.
- *
- * Instead, it returns a _**Real-time proxy**_. This means that a value is read
- * from the source object each time a property is accessed through the proxy.
- * So accessing a property through the gate object is guaranteed to always return
- * the latest value.
- */
-export declare const ObjectGate: _ObjectGate.IConstructor;
-export {};

package/build/helpers/object-gate.js

@@ -1,64 +0,0 @@
-var _ObjectGate;
-(function (_ObjectGate) {
-    class Gate {
-        constructor(...params) {
-            var _a, _b, _c, _d;
-            const [source, config] = params;
-            const getters = (_a = config === null || config === void 0 ? void 0 : config.getters) !== null && _a !== void 0 ? _a : Reflect.ownKeys(source);
-            const gettersExclude = (_b = config === null || config === void 0 ? void 0 : config.gettersExclude) !== null && _b !== void 0 ? _b : [];
-            const setters = (config === null || config === void 0 ? void 0 : config.setters) === true
-                ? getters
-                : ((_c = config === null || config === void 0 ? void 0 : config.setters) !== null && _c !== void 0 ? _c : []);
-            const settersExclude = (_d = config === null || config === void 0 ? void 0 : config.settersExclude) !== null && _d !== void 0 ? _d : [];
-            getters.forEach((_key) => {
-                const key = _key;
-                if (gettersExclude.includes(key))
-                    return;
-                Object.defineProperty(this, key, {
-                    enumerable: true,
-                    configurable: true,
-                    get() {
-                        return source[key];
-                    },
-                });
-            });
-            setters.forEach((_key) => {
-                const key = _key;
-                if (settersExclude.includes(key))
-                    return;
-                Object.defineProperty(this, key, {
-                    enumerable: true,
-                    set(value) {
-                        source[key] = value;
-                    },
-                });
-            });
-        }
-    }
-    _ObjectGate.Gate = Gate;
-    ;
-})(_ObjectGate || (_ObjectGate = {}));
-/**
- * Creates a new object that acts as a real-time proxy
- * for the {@link _ObjectGate.Params | `source`} object.
- * This lets you prevent access to some properties, effectively making them private,
- * while selectively exposing access to only the properties you specify
- * in the {@link _ObjectGate.IGateConfig.getters | `getters`} config option.
- *
- * The exposed properties are read-only by default,
- * exposing only a [getter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description)
- * with no corresponding [setter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set#description).
- *
- * The {@link _ObjectGate.Params | `config`} argument also lets you selectively allow
- * write access to specific properties through the
- * {@link _ObjectGate.IGateConfig.setters | `setters`} config option.
- *
- * Unlike [`structuredClone`](https://developer.mozilla.org/docs/Web/API/Window/structuredClone)
- * this doesn't return a _copy_ of the `source` object.
- *
- * Instead, it returns a _**Real-time proxy**_. This means that a value is read
- * from the source object each time a property is accessed through the proxy.
- * So accessing a property through the gate object is guaranteed to always return
- * the latest value.
- */
-export const ObjectGate = _ObjectGate.Gate;