ivue 1.5.7 → 1.6.1

package/dist/ivue.d.ts

@@ -1,25 +1,35 @@
-import type { ComputedRef, ExtractPropTypes, Ref, ToRef } from 'vue';
+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> & ExtendWithToRefs<T>;
+export declare type IVue<T extends AnyClass> = InstanceType<T> & {
+    toRefs: IVueToRefsFn<T>;
+    clone: IVueClone<T>;
+};
 /**
- * Extend with .toRefs() method, so that a reactive class can be converted to a composable definition.
+ * Type definition for `.clone()` method creates a deep clone of the ivue instance.
  */
-export interface ExtendWithToRefs<T extends AnyClass> {
-    toRefs: IVueToRefsFn<T>;
-}
+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.
  */
-export interface IVueToRefsFn<T extends AnyClass> {
-    <P extends keyof InstanceType<T>>(props: P[]): Pick<IVueRefs<InstanceType<T>>, P>;
-    <P extends keyof InstanceType<T>>(props: P[], unwrap: false): Pick<IVueRefs<InstanceType<T>>, P>;
-    <P extends keyof InstanceType<T>>(props: P[], unwrap: true): Pick<InstanceType<T>, P>;
-    (props: true): InstanceType<T>;
+/** 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>>;
 }
@@ -28,7 +38,7 @@ export interface IVueToRefsFn<T extends AnyClass> {
  * also knows NOT to convert functions to .value Refs but to leave them as is.
  */
 export declare type IVueRefs<T> = {
-    [K in keyof T]: T[K] extends Function ? T[K] : ToRef<T[K]>;
+    [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
@@ -37,19 +47,19 @@ export declare type IVueRefs<T> = {
  * are difficult to fully resolve to bare values without this utility.
  * Also support Vue 3 Demi for vue-use library support.
  */
-export declare type UnwrapRefRecursively<T = any> = T extends Ref | DemiRef ? UnwrapRefRecursively<T['value']> : T;
+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 down to its bare types.
+ * Helper type for Use type, unwraps any type of Vue 3 composable return object down to its bare types.
  */
-export declare type Unwrap<T> = T extends Ref | DemiRef ? UnwrapRefRecursively<T> : {
+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> : Unwrap<T extends AnyFn ? ReturnType<T> : T>;
+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
+ * 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;
@@ -72,15 +82,11 @@ export declare type AnyFn = (...args: any[]) => any;
 /**
  * Any JavaScript class of any type.
  */
-export declare type AnyClass = abstract new (...args: any[]) => any;
+export declare type AnyClass = new (...args: any[]) => any;
 /**
- * Descriptors map type.
+ * Accessors map type.
  */
-export declare type Descriptors = Map<string, PropertyDescriptor>;
-/**
- * Computeds hash map type.
- */
-export declare type Computeds = Record<string, ComputedRef>;
+declare type Accessors = Map<string, PropertyDescriptor>;
 /**
  * Infer paramaters of a constructor function of a Class.
  */
@@ -93,14 +99,6 @@ export declare type InferredArgs<T> = T extends {
 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 Interface's property's function arguments Parmeters<F>
- */
-export declare type IFnParameters<T extends Record<any, any>, K extends string> = Parameters<Required<Pick<T, K>>[K]>;
-/**
- * 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>;
 /**
  * Get function arguments Parmeters<F> parameter by key K
  */
@@ -108,34 +106,96 @@ export declare type FnParameter<F extends AnyFn, K extends number> = Parameters<
 /**
  * Convert Union Type to Intersection Type.
  */
-export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
  * Convert Record to Union Type.
  */
-export declare type RecordToUnion<T extends Record<string, any>> = T[keyof T];
+declare type RecordToUnion<T extends Record<string, any>> = T[keyof T];
 /**
  * Gets object T property by key [K].
  */
-export declare type ValueOf<T extends Record<any, any>, K> = T[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;
 /**
- * Store all descriptors for each class prototype processed by
- * @see {getAllClassDescriptors}
+ * 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 const descriptorsMap: Map<any, any>;
+export declare let accessorsMethodsMaps: WeakMap<object, AccessorsMethodsMap>;
 /**
- * Get descriptors of an entire class prototype ancestors chain as a Map.
- * Completely emulates JavaScript class inheritance chain for getters and setters.
- *
- * @param className
- * @return {Descriptors}
+ * Property kind enum for distinguishing between data properties and accessors.
  */
-export declare function getAllClassDescriptors(className: AnyClass): Descriptors;
+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 descriptors are converted to computeds.
+ * where accessors are converted to computeds.
  *
  * You can turn off computed behaviour by adding static
  * ivue object and setting the getter props to false.
@@ -151,46 +211,30 @@ export declare function getAllClassDescriptors(className: AnyClass): Descriptors
  * @param args Class constructor arguments that you would pass to a `new AnyClass(args...)`
  * @returns {IVue<T>}
  */
-export declare function ivue<T extends AnyClass>(className: T, ...args: InferredArgs<T>): IVue<T>;
-/**
- * Store all props for each class prototype processed by:
- * @see {getAllClassProperties}
- */
-export declare const propsMap: Map<object, Set<string> | any>;
-/**
- * Get properties of an entire class prototype ancestors chain as a Map.
- */
-export declare function getAllClassProperties(obj: object): Set<string>;
+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}
+ * @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}
+ * @returns {T} ShallowRef but with type unwrapped
  */
 export declare const ishallowRef: <T = any>(value?: T | undefined) => T;
 /**
- * Three modes of operation:
- * 1. `iuse(useComposable(arg, arg2, arg3, ...))` converts the return types of a Composable / Ref to pure raw unwrapped type definition.
- * Returns for all properties of an object an unwrapped raw type definition,
- * unwraps direct Refs & ComputedRefs as well down to their raw types.
+ * `iuse()` is a helper function that unwraps any Vue 3 composable return type down to its bare types.
  *
- * 2. `iuse(useComposable, arg, arg2, arg3, ...)` for cleaner syntax for #1, it does exactly the same thing but
- * here the TypeScript inference works for composable function arguments to assist you with intellisence,
- * like they work for constructor arguments in the cause of `ivue()` core function,
- * making the API cleaner to look at and make it compatible with how this function operates with classes, see #3.
+ * It does not alter the behavior of the composable, but simply transforms the type to an unwrapped raw value.
  *
- * 3. `iuse(AnyClass, ...args)` If AnyClass is supplied and that class's arguments into `iuse(AnyClass, ...args)`,
- * it returns an 'ivue(AnyClass, ...args).toRefs()` object for all properties but casts
- * their types as raw (no-Ref) types to fit with reactive() structure of the ivue class context.
+ * @param obj Any Vue 3 composable return type or any object or any type
+ * @returns {Use<T>} Composable with types unwrapped
  */
-export declare function iuse<T extends AnyClass | AnyFn | Object | any>(classFunctionObject?: T, ...args: T extends AnyClass ? InferredArgs<T> : T extends AnyFn ? Parameters<T extends (...args: any[]) => any ? T : any> : any): T extends AnyClass ? InstanceType<T> : Use<T>;
+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.
  */
@@ -216,7 +260,7 @@ export declare type VuePropsWithDefaults<T extends VuePropsObject> = {
  * @param val Any value
  * @returns boolean If it's a JavaScript Class returns true
  */
-export declare function isClass(val: any): boolean;
+export declare const isClass: (val: any) => boolean;
 /**
  * Creates props with defaults in defineComponent() style.
  *
@@ -242,6 +286,25 @@ export declare function isClass(val: any): boolean;
  * @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 function propsWithDefaults<T extends VuePropsObject>(defaults: Record<string, any>, typedProps: T): VuePropsWithDefaults<T>;
+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 {};

package/lib/Reactive.ts

@@ -0,0 +1,338 @@
+import { toRaw, isRef, type Ref } from 'vue';
+
+/**
+ * Constants & Helpers
+ */
+const prototypeHasOwnProperty = Object.prototype.hasOwnProperty.call.bind(
+  Object.prototype.hasOwnProperty
+);
+const getPrototypeOf = Object.getPrototypeOf;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const defineProperty = Object.defineProperty;
+const getOwnPropertyNames = Object.getOwnPropertyNames;
+const objectPrototype = Object.prototype;
+const getOwnPropertySymbols = Object.getOwnPropertySymbols;
+
+const $stopEffects = '$stopEffects';
+const fn = 'function';
+const RAW = Symbol('ivue_raw');
+const SK_MAP = '__ivue_sk'; // Store for cache keys
+const PROCESSED = Symbol('ivue_processed'); // Flag to mark prototype as "Reactified"
+
+/**
+ * Get unique symbol key for super method/property.
+ */
+function getSuperKey(proto: any, key: string): symbol {
+  // Ensure the map exists on this specific prototype (shadowing parents)
+  if (!prototypeHasOwnProperty(proto, SK_MAP)) {
+    defineProperty(proto, SK_MAP, {
+      value: {},
+      configurable: true,
+      enumerable: false,
+      writable: true,
+    });
+  }
+  const map = proto[SK_MAP];
+  return map[key] || (map[key] = Symbol(key));
+}
+
+/**
+ * Convert method to a lazy-bound prototype method.
+ */
+function convertToLazyBoundMethod(proto: any, key: string, superKey: symbol) {
+  const desc = getOwnPropertyDescriptor(proto, key);
+  if (!desc || typeof desc.value !== fn) return;
+
+  const originalFn = desc.value;
+
+  defineProperty(proto, key, {
+    configurable: true,
+    enumerable: false,
+    get(this: any) {
+      const raw = this[RAW] ?? (this[RAW] = toRaw(this));
+      return raw[superKey] ?? (raw[superKey] = originalFn.bind(raw));
+    },
+    set(this: any, newFn: any) {
+      toRaw(this)[superKey] = newFn;
+    },
+  });
+}
+
+/**
+ * Convert a property to a lazy-computed property.
+ */
+function convertToLazyComputed<T extends object>(
+  proto: T,
+  key: string,
+  superKey: symbol
+) {
+  const desc = getOwnPropertyDescriptor(proto, key);
+  const originalGetter = desc?.get;
+  const originalSetter = desc?.set;
+
+  // Optimization: Properties starting with $ are assumed singletons
+  const cacheWhole = key[0] === '$';
+
+  // DEV WARNING: Setter/Getter mismatch
+  if (import.meta.env.DEV && originalGetter && originalSetter) {
+    try {
+      const testVal = originalGetter.call({});
+      if (isRef(testVal)) {
+        console.warn(
+          `[ivue] API conflict on "${key}": Getter returns Ref but Setter is standard.`
+        );
+      }
+    } catch (e) {}
+  }
+
+  const newGetter = function (this: any) {
+    const raw = toRaw(this);
+
+    // 1. Check Cache
+    if (superKey in raw) return raw[superKey];
+
+    // 2. Execute Original
+    const result = originalGetter!.call(raw);
+
+    // 3. Handle Result
+    if (cacheWhole) {
+      // Cache result forever (Singleton pattern)
+      raw[superKey] = result;
+      return result;
+    }
+
+    if (isRef(result)) {
+      // Cache Ref instance (Reactivity pattern)
+      raw[superKey] = result;
+    } else {
+      // DE-OPTIMIZATION: It's just a value. Restore original getter on prototype.
+      // This removes overhead for all future calls on this prototype.
+      defineProperty(proto, key, {
+        configurable: true,
+        enumerable: false,
+        get: originalGetter
+          ? function (this: any) {
+              return originalGetter.call(toRaw(this));
+            }
+          : undefined,
+        set: originalSetter
+          ? function (this: any, v: any) {
+              return originalSetter.call(toRaw(this), v);
+            }
+          : undefined,
+      });
+    }
+
+    return result;
+  };
+
+  defineProperty(proto, key, {
+    configurable: true,
+    enumerable: false,
+    get: originalGetter ? newGetter : undefined,
+    set: originalSetter
+      ? function (this: any, v: any) {
+          return originalSetter.call(toRaw(this), v);
+        }
+      : undefined,
+  });
+}
+
+/**
+ * Create a reactive class.
+ * @param targetClass The class to make reactive.
+ * @returns A reactive version of the class.
+ */
+export function Reactive<C extends new (...args: any) => any>(
+  targetClass: C
+): ReactiveClass<C> & { Instance: ReactiveInstance<InstanceType<C>> } {
+  const chain: any[] = [];
+
+  let targetPrototype = targetClass.prototype;
+  while (targetPrototype && targetPrototype !== objectPrototype) {
+    chain.push(targetPrototype);
+    targetPrototype = getPrototypeOf(targetPrototype);
+  }
+
+  // Process Base -> Child
+  chain.reverse();
+
+  for (const prototype of chain) {
+    // OPTIMIZATION: Skip if this prototype layer is already "Reactified"
+    // This handles diamond inheritance and multiple Reactive children safely.
+    if (prototypeHasOwnProperty(prototype, PROCESSED)) continue;
+
+    const names = getOwnPropertyNames(prototype);
+
+    for (const key of names) {
+      if (key === 'constructor') continue;
+      const desc = getOwnPropertyDescriptor(prototype, key);
+      if (!desc) continue;
+
+      const superKey = getSuperKey(prototype, key);
+
+      if (typeof desc.value === fn) {
+        convertToLazyBoundMethod(prototype, key, superKey);
+      } else if (desc.get) {
+        convertToLazyComputed(prototype, key, superKey);
+      }
+    }
+
+    // Mark this specific prototype level as processed
+    defineProperty(prototype, PROCESSED, {
+      configurable: false,
+      enumerable: false,
+      value: true,
+    });
+  }
+
+  // Inject cleanup
+  if (!prototypeHasOwnProperty(targetClass.prototype, $stopEffects)) {
+    defineProperty(targetClass.prototype, $stopEffects, {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value: function (this: any) {
+        const raw = toRaw(this);
+        if (typeof raw.stopEffects === fn) raw.stopEffects();
+
+        const symbols = getOwnPropertySymbols(raw);
+        for (const symbol of symbols) {
+          if (symbol === RAW) continue;
+          const cached = raw[symbol];
+          // Stop computed/effect if present
+          if (cached && cached.effect && typeof cached.effect.stop === fn) {
+            cached.effect.stop();
+          }
+          delete raw[symbol];
+        }
+      },
+    });
+  }
+
+  return targetClass as any;
+}
+
+/**
+ * Vue props interface in defineComponent() style.
+ */
+export type VuePropsObject = Record<
+  string,
+  { type: any; default?: any; required?: boolean }
+>;
+
+/**
+ * Vue Props with default properties declared as existing and having values.
+ */
+export 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 const isClass = (val: any): boolean => {
+  if (typeof val !== 'function') return false; // Not a function, so not a class function either
+
+  if (!val.prototype) return false; // Arrow function, so not a class
+
+  // Finally -> distinguish between a normal function and a class function
+  if (getOwnPropertyDescriptor(val, 'prototype')?.writable) {
+    // Has writable prototype
+    return false; // Normal function
+  } else {
+    return true; // Class -> Not a function
+  }
+};
+/**
+ * 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 const propsWithDefaults = <T extends VuePropsObject>(
+  defaults: Record<string, any>,
+  typedProps: T,
+  // Optional: Allows user to pass a custom cloner if structuredClone isn't enough
+  customCloner?: (val: any) => any
+): VuePropsWithDefaults<T> => {
+  for (const prop in typedProps) {
+    const def = defaults?.[prop];
+    const typed = typedProps[prop];
+
+    if (typed.required || def === undefined) continue;
+
+    if (typeof def === 'object' && def !== null) {
+      typedProps[prop].default = () =>
+        customCloner ? customCloner(def) : structuredClone(def);
+    } else {
+      if (isClass(def)) {
+        typedProps[prop].default = () => def;
+      } else {
+        typedProps[prop].default = def;
+      }
+    }
+  }
+  return typedProps as VuePropsWithDefaults<T>;
+};
+
+/**
+ * Type Utilities
+ */
+type GetterKeys<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any
+    ? never
+    : T[K] extends undefined
+    ? never
+    : K;
+}[keyof T];
+
+type GetterReturn<T, K extends keyof T> = T[K] extends (...args: any[]) => any
+  ? never
+  : T[K];
+type WritableComputedLike = Ref<any> & { set: (...args: any[]) => any };
+type IsWritableGetter<R> = R extends Ref<any>
+  ? true
+  : R extends WritableComputedLike
+  ? true
+  : false;
+
+type WritableGetters<T> = {
+  [K in GetterKeys<T> as IsWritableGetter<GetterReturn<T, K>> extends true
+    ? K
+    : never]-?: T[K];
+};
+
+export type ReactiveInstance<T> = T &
+  WritableGetters<T> & { $stopEffects: () => void };
+
+export type ReactiveClass<C extends new (...args: any) => any> = new (
+  ...args: ConstructorParameters<C>
+) => ReactiveInstance<InstanceType<C>>;