npm - ivue - Versions diffs - 1.5.3 → 1.5.4 - Mend

ivue 1.5.3 → 1.5.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export * from './ivue';

package/dist/index.es.js ADDED Viewed

@@ -0,0 +1,89 @@
+import { reactive as R, computed as b, ref as v, shallowRef as A, toRef as m } from "vue";
+const d = /* @__PURE__ */ new Map();
+function D(e) {
+  if (d.has(e))
+    return d.get(e);
+  const o = /* @__PURE__ */ new Map();
+  let t = e.prototype;
+  for (; t.constructor !== Object; )
+    Object.entries(Object.getOwnPropertyDescriptors(t)).forEach(([f, r]) => {
+      const i = o.get(f);
+      i !== r && (r != null && r.get || r != null && r.set) && (i != null && i.get && (r.get = i == null ? void 0 : i.get), i != null && i.set && (r.set = i == null ? void 0 : i.set), o.set(f, r));
+    }), t = Object.getPrototypeOf(t);
+  return d.set(e, o), o;
+}
+function E(e, ...o) {
+  var i, O;
+  const t = D(e), f = t != null && t.size ? {} : null, r = R(new e(...o));
+  for (const [n, l] of t)
+    ((i = e == null ? void 0 : e.ivue) == null ? void 0 : i[n]) !== !1 && Object.defineProperty(r, n, { get: l.get ? () => {
+      var a, g;
+      return n in f ? f[n] : f[n] = b({ get: (a = l.get) == null ? void 0 : a.bind(r), set: (g = l.set) == null ? void 0 : g.bind(r) });
+    } : void 0, set: (O = l.set) == null ? void 0 : O.bind(r), enumerable: !1 });
+  return Object.defineProperty(r, "toRefs", { get: () => function(n, l, a) {
+    return function(g, S) {
+      var w, h;
+      const p = {};
+      if (Array.isArray(g))
+        for (let u = 0; u < g.length; u++) {
+          const s = g[u];
+          if (l.has(s))
+            if (s in a)
+              p[s] = a[s];
+            else {
+              const c = l.get(s);
+              p[s] = a[s] = b({ get: (w = c == null ? void 0 : c.get) == null ? void 0 : w.bind(n), set: (h = c == null ? void 0 : c.set) == null ? void 0 : h.bind(n) });
+            }
+          else
+            typeof n[s] == "function" ? p[s] = n[s].bind(n) : p[s] = m(n, s);
+        }
+      else {
+        let u = new Set(C(n));
+        l.forEach((s, c) => {
+          var j, P;
+          p[c] = c in a ? a[c] : a[c] = b({ get: (j = s.get) == null ? void 0 : j.bind(n), set: (P = s.set) == null ? void 0 : P.bind(n) }), u == null || u.delete(c);
+        }), u.forEach((s) => {
+          typeof n[s] == "function" ? p[s] = n[s].bind(n) : p[s] = m(n, s);
+        }), u = null;
+      }
+      return p;
+    };
+  }(r, t, f), enumerable: !1 }), "init" in r && r.init(), r;
+}
+const y = /* @__PURE__ */ new Map();
+function C(e) {
+  if (y.has(e.constructor))
+    return y.get(e.constructor);
+  const o = e.constructor, t = /* @__PURE__ */ new Set();
+  do
+    Object.getOwnPropertyNames(e).forEach((f) => {
+      ["caller", "callee", "arguments", "constructor"].includes(f) || t.add(f);
+    }), e = Object.getPrototypeOf(e);
+  while (e.constructor !== Object);
+  return y.set(o, t), t;
+}
+const z = v, N = A;
+function W(e, ...o) {
+  return typeof e == "function" ? M(e) ? E(e, ...o).toRefs(!0) : e(...o) : e;
+}
+function M(e) {
+  var o;
+  return typeof e == "function" && !!e.prototype && !((o = Object.getOwnPropertyDescriptor(e, "prototype")) != null && o.writable);
+}
+function k(e, o) {
+  for (const t in o)
+    typeof (e == null ? void 0 : e[t]) == "object" && (e == null ? void 0 : e[t]) !== null || M(e == null ? void 0 : e[t]) ? o[t].default = () => e == null ? void 0 : e[t] : o[t].default = e == null ? void 0 : e[t];
+  return o;
+}
+export {
+  d as descriptorsMap,
+  D as getAllClassDescriptors,
+  C as getAllClassProperties,
+  z as iref,
+  M as isClass,
+  N as ishallowRef,
+  W as iuse,
+  E as ivue,
+  y as propsMap,
+  k as propsWithDefaults
+};

package/dist/index.umd.js ADDED Viewed

@@ -0,0 +1 @@

package/dist/ivue.d.ts ADDED Viewed

@@ -0,0 +1,247 @@
+import type { ComputedRef, 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>;
+/**
+ * Extend with .toRefs() method, so that a reactive class can be converted to a composable definition.
+ */
+export interface ExtendWithToRefs<T extends AnyClass> {
+    toRefs: IVueToRefsFn<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>;
+    (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 = any> = {
+    [K in keyof T]: T[K] extends Function ? T[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.
+ */
+export 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.
+ */
+export declare type Unwrap<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> = Unwrap<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 = abstract new (...args: any[]) => any;
+/**
+ * Descriptors map type.
+ */
+export declare type Descriptors = Map<string, PropertyDescriptor>;
+/**
+ * Computeds hash map type.
+ */
+export declare type Computeds = Record<string, ComputedRef>;
+/**
+ * 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 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
+ */
+export declare type FnParameter<F extends AnyFn, K extends number> = Parameters<F>[K];
+/**
+ * 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;
+/**
+ * Convert Record to Union Type.
+ */
+export 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];
+/** Types End. */
+/**
+ * Store all descriptors for each class prototype processed by
+ * @see {getAllClassDescriptors}
+ */
+export declare const descriptorsMap: Map<any, any>;
+/**
+ * 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}
+ */
+export declare function getAllClassDescriptors(className: AnyClass): Descriptors;
+/**
+ * Infinite Vue (ivue) class reactive initializer.
+ *
+ * Converts class instance to a reactive object,
+ * where descriptors 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 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>;
+/**
+ * `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}
+ */
+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}
+ */
+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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+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>;
+/**
+ * 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 function 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 function propsWithDefaults<T extends VuePropsObject>(defaults: Record<string, any>, typedProps: T): VuePropsWithDefaults<T>;
+/** Necessary ivue.ts to be treated as a module. */
+export {};

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ivue",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "description": "Infinite Vue – Class Based Architecture for Vue 3",
   "type": "module",
   "exports": {
@@ -86,7 +86,8 @@
     "email": "ekalashnikov@gmail.com"
   },
   "files": [
-    "lib"
+    "lib",
+    "dist"
   ],
   "license": "MIT",
   "dependencies": {}