ivue 1.6.1 → 2.0.0

package/dist/ivue.d.ts

@@ -1,310 +0,0 @@
-import type { ExtractPropTypes, Ref, ToRef } from 'vue';
-import type { Ref as DemiRef } from 'vue-demi';
-/** Types */
-/**
- * IVue core reactive instance type with an extended .toRefs() method added.
- */
-export declare type IVue<T extends AnyClass> = InstanceType<T> & {
-    toRefs: IVueToRefsFn<T>;
-    clone: IVueClone<T>;
-};
-/**
- * Type definition for `.clone()` method creates a deep clone of the ivue instance.
- */
-export declare type IVueClone<T extends AnyClass> = (...cloneArgs: CloneArgsFor<InstanceType<T>>) => IVue<T>;
-/**
- * Type definition for `.toRefs()` method converts reactive class properties to composable .value properties.
- * But if props = true OR unwrap = true is specified, the refs will be unwrapped refs to be able to be merged with the the root class properties without losing reactivity.
- */
-/** Extract only non-method keys from a type */
-declare type NonMethodKeys<T> = {
-    [K in keyof T]: T[K] extends AnyFn ? never : K;
-}[keyof T];
-/** Create a type with only data properties and accessors */
-declare type DataProperties<T> = Pick<T, NonMethodKeys<T>>;
-/**
- * Simplified IVueToRefsFn that only works with data properties
- */
-interface IVueToRefsFn<T extends AnyClass> {
-    <P extends keyof IVueRefs<InstanceType<T>>>(props: P[]): Pick<IVueRefs<InstanceType<T>>, P>;
-    <P extends keyof IVueRefs<InstanceType<T>>>(props: P[], unwrap: false): Pick<IVueRefs<InstanceType<T>>, P>;
-    <P extends keyof DataProperties<InstanceType<T>>>(props: P[], unwrap: true): Pick<DataProperties<InstanceType<T>>, P>;
-    (props: true): DataProperties<InstanceType<T>>;
-    (props: false): IVueRefs<InstanceType<T>>;
-    (): IVueRefs<InstanceType<T>>;
-}
-/**
- * Converts a class properties to a composable .value Refs using ToRef vue type,
- * also knows NOT to convert functions to .value Refs but to leave them as is.
- */
-export declare type IVueRefs<T> = {
-    [K in keyof T as T[K] extends AnyFn ? never : K]: ToRef<T[K]>;
-};
-/**
- * Unwraps Ref Recursively, helps resolve fully the bare value types of any type T
- * because sometimes the Refs are returned as they are with `.value` from computeds,
- * thus inferring nested ComputedRef<ComputedRef<ComputedRef<Ref>>> types, which
- * are difficult to fully resolve to bare values without this utility.
- * Also support Vue 3 Demi for vue-use library support.
- */
-declare type UnwrapRefRecursively<T = any> = T extends Ref | DemiRef ? UnwrapRefRecursively<T['value']> : T;
-/**
- * Helper type for Use type, unwraps any type of Vue 3 composable return object down to its bare types.
- */
-declare type UnwrapComposableRefs<T> = T extends Ref | DemiRef ? UnwrapRefRecursively<T> : {
-    [K in keyof T]: T[K] extends Ref | DemiRef ? UnwrapRefRecursively<T[K]> : T[K];
-};
-/**
- * Fully unwraps to bare value types any Vue 3 composable return definition type.
- */
-export declare type Use<T = any> = T extends Ref | DemiRef ? UnwrapRefRecursively<T> : UnwrapComposableRefs<T extends AnyFn ? ReturnType<T> : T>;
-/**
- * Extracts object defined emit types by converting them to a plain interface.
- */
-export declare type ExtractEmitTypes<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{
-    [K in keyof T]: (evt: K, ...args: Parameters<T[K]>) => void;
-}>>;
-/**
- * Extract properties as all assigned properties because they have defaults.
- */
-export declare type ExtractPropDefaultTypes<O> = {
-    [K in keyof O]: ValueOf<ExtractPropTypes<O>, K>;
-};
-/**
- * Extend slots interface T with prefixed 'before--' & 'after--' slots to create fully extensible flexible slots.
- */
-export declare type ExtendSlots<T> = PrefixKeys<T, 'before--'> & T & PrefixKeys<T, 'after--'>;
-/** Helper Types. */
-/**
- * Any JavaScript function of any type.
- */
-export declare type AnyFn = (...args: any[]) => any;
-/**
- * Any JavaScript class of any type.
- */
-export declare type AnyClass = new (...args: any[]) => any;
-/**
- * Accessors map type.
- */
-declare type Accessors = Map<string, PropertyDescriptor>;
-/**
- * Infer paramaters of a constructor function of a Class.
- */
-export declare type InferredArgs<T> = T extends {
-    new (...args: infer P): any;
-} ? P : never[];
-/**
- * Prefix keys of an interface T with a prefix P.
- */
-export declare type PrefixKeys<T, P extends string | undefined = undefined> = {
-    [K in Extract<keyof T, string> as P extends string ? `${P}${K}` : K]: T[K];
-};
-/**
- * Get function arguments Parmeters<F> parameter by key K
- */
-export declare type FnParameter<F extends AnyFn, K extends number> = Parameters<F>[K];
-/**
- * Convert Union Type to Intersection Type.
- */
-declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
- * Convert Record to Union Type.
- */
-declare type RecordToUnion<T extends Record<string, any>> = T[keyof T];
-/**
- * Gets object T property by key [K].
- */
-declare type ValueOf<T extends Record<any, any>, K> = T[K];
-/**
- * Props Map Value type.
- */
-declare type PropsMapValue = {
-    allProps: Map<string, PropKind>;
-    onlyProps: Set<string>;
-};
-/**
- * Accessors and Methods map type.
- */
-declare type AccessorsMethodsMap = {
-    accessors: Accessors;
-    methods: Set<string>;
-};
-export declare type IVueInstanceBase = {
-    init?: (...args: any[]) => void;
-};
-/**
- * IVue static configuration interface.
- */
-export interface IVueStaticConfig<T> {
-    ivueGlobalStore?: boolean;
-    ivueCloneByReference?: Set<keyof T>;
-    ivueDisableReactivity?: Set<keyof T>;
-}
-/**
- * IVue constructor type.
- */
-export declare type IVueConstructor<T> = new (...args: any[]) => T;
-/**
- * IVue class type with static configuration.
- */
-export declare type IVueClass<T> = IVueConstructor<T> & IVueStaticConfig<T>;
-/**
- * Get IVue init() method arguments IVueInitArgs<T>
- */
-export declare type IVueInitArgs<T extends IVueInstanceBase> = T['init'] extends (...args: any[]) => any ? Parameters<T['init']> : never;
-/**
- * Get Interface's method keys MethodKeys<T>
- */
-declare type MethodKeys<T> = {
-    [P in keyof T]: T[P] extends (...args: any[]) => any ? P : never;
-}[keyof T];
-/**
- * Get Interface's property's function arguments Parameters<F>
- */
-export declare type IFnParameters<T extends Record<any, any> | InstanceType<AnyClass>, K extends MethodKeys<T>> = Parameters<Extract<Required<Pick<T, K>>[K], AnyFn>>;
-/**
- * Get Interface's [T] property's [P] function arguments Parmeters<F> parameter by key [K]
- */
-export declare type IFnParameter<T extends Record<any, any>, P extends keyof T, K extends number> = FnParameter<ValueOf<T, P>, K>;
-export declare type IVueDeepCloneArgsMap = Map<AnyClass, any[]>;
-declare type CloneArgsFor<T> = T extends {
-    init: (isClone: boolean, ...rest: infer A) => any;
-} ? A : [];
-/** Types End. */
-export declare const IVUE_INSTANCE_SYMBOL: unique symbol;
-/**
- * Stores accessors for each class prototype processed by
- * @see {getClassAccessorsMethodsMap}. Uses WeakMap to allow garbage collection
- * of unused class accessors, ensuring memory efficiency in long-running applications.
- */
-export declare let accessorsMethodsMaps: WeakMap<object, AccessorsMethodsMap>;
-/**
- * Property kind enum for distinguishing between data properties and accessors.
- */
-declare const enum PropKind {
-    Data = 0,
-    Accessor = 2
-}
-/**
- * Stores properties for each class prototype processed by
- * @see {getClassPropertiesAccessorsMap}. Uses WeakMap to allow garbage collection
- * of unused class properties, ensuring memory efficiency in long-running applications.
- */
-export declare let propertiesAccessorsMaps: WeakMap<object, PropsMapValue>;
-/**
- * Infinite Vue (ivue) class reactive initializer.
- *
- * Converts class instance to a reactive object,
- * where accessors are converted to computeds.
- *
- * You can turn off computed behaviour by adding static
- * ivue object and setting the getter props to false.
- * class ClassName {
- *    static ivue = {
- *      getter: false
- *    }
- *    // .getter -> will be a standard JS non-computed getter
- *    get getter () { return 'hello world'; }
- * }
- *
- * @param className Any Class
- * @param args Class constructor arguments that you would pass to a `new AnyClass(args...)`
- * @returns {IVue<T>}
- */
-export declare const ivue: <T extends AnyClass>(className: T, ...args: InferredArgs<T>) => IVue<T>;
-/**
- * `iref()` is an alias for Vue ref() function but returns an unwrapped type without the .value
- * `iref()` does not alter the behavior of ref(), but simply transforms the type to an unwrapped raw value.
- * @param val T
- * @returns {T} Ref but with type unwrapped
- */
-export declare const iref: <T = any>(value?: T | undefined) => T;
-/**
- * `ishallowRef()` is an alias for Vue shallowRef() function but returns an unwrapped type without the .value
- * `ishallowRef()` does not alter the behavior of shallowRef(), but simply transforms the type to an unwrapped raw value.
- * @param val T
- * @returns {T} ShallowRef but with type unwrapped
- */
-export declare const ishallowRef: <T = any>(value?: T | undefined) => T;
-/**
- * `iuse()` is a helper function that unwraps any Vue 3 composable return type down to its bare types.
- *
- * It does not alter the behavior of the composable, but simply transforms the type to an unwrapped raw value.
- *
- * @param obj Any Vue 3 composable return type or any object or any type
- * @returns {Use<T>} Composable with types unwrapped
- */
-export declare const iuse: <T extends object>(obj: T) => Use<T>; /** Unwrap any other Object or any type down to its bare types. */
-/**
- * Vue props interface in defineComponent() style.
- */
-export declare type VuePropsObject = Record<string, {
-    type: any;
-    default?: any;
-    required?: boolean;
-}>;
-/**
- * Vue Props with default properties declared as existing and having values.
- */
-export declare type VuePropsWithDefaults<T extends VuePropsObject> = {
-    [K in keyof T]: {
-        type: T[K]['type'];
-        default: T[K]['default'];
-        required?: boolean;
-    };
-};
-/**
- * Determines if the value is a JavaScript Class.
- * Note that class is a class function in JavaScript.
- *
- * @param val Any value
- * @returns boolean If it's a JavaScript Class returns true
- */
-export declare const isClass: (val: any) => boolean;
-/**
- * Creates props with defaults in defineComponent() style.
- *
- * Merge defaults regular object with Vue types object
- * declared in defineComponent() style.
- *
- * This is made so that the defaults can be declared "as they are"
- * without requiring objects to be function callbacks returning an object.
- *
- * // You don't need to wrap objects in () => ({ nest: { nest :{} } })
- * // You can just delcare them normally.
- * const defaults = {
- *    nest: {
- *      nest
- *    }
- * }
- *
- * This function will create the Vue expected callbacks for Objects, Arrays & Classes
- * but leave primitive properties and functions intact so that
- * the final object is fully defineComponent() style compatible.
- *
- * @param defaults Regular object of default key -> values
- * @param typedProps Props declared in defineComponent() style with type and possibly required declared, but without default
- * @returns Props declared in defineComponent() style with all properties having default property declared.
- */
-export declare const propsWithDefaults: <T extends VuePropsObject>(defaults: Record<string, any>, typedProps: T, deepCloneArgs?: IVueDeepCloneArgsMap | undefined) => VuePropsWithDefaults<T>;
-/**
- * Copies own properties (including symbols and non-enumerable) from source to target.
- * Recursively deep clones values, but preserves getters/setters as-is.
- */
-export declare const copyOwnProps: (source: any, target: any, deepCloneArgs: IVueDeepCloneArgsMap | undefined, seen: WeakMap<object, any>) => void;
-export declare let activeDeepCloneArgsMap: WeakMap<AnyClass, IVueDeepCloneArgsMap>;
-export declare const deepClone: (source: any, deepCloneArgs?: IVueDeepCloneArgsMap, seen?: WeakMap<object, any>) => any;
-/**
- * Clears the accessorsMethodsMaps, and propertiesAccessorsMaps WeakMaps.
- * Useful for SSR scenarios where you want to reset the cache between requests.
- * Also useful for testing purposes to ensure a clean state.
- */
-export declare const clearCache: () => void;
-/** Exported for testing purposes. */
-export declare const __test__: {
-    copyOwnProps: (source: any, target: any, deepCloneArgs: IVueDeepCloneArgsMap | undefined, seen: WeakMap<object, any>) => void;
-    getClassAccessorsMethodsMap: (className: AnyClass) => AccessorsMethodsMap;
-    getClassPropertiesAccessorsMap: (obj: object) => PropsMapValue;
-};
-/** Necessary ivue.ts to be treated as a module. */
-export {};