pinia-orm-edge 1.7.3-28257628.bbb8bab

package/dist/decorators.mjs

@@ -0,0 +1,198 @@
+function Attr(value) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(propertyKey, () => self.attr(value));
+  };
+}
+
+function Str(value, options = {}) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(propertyKey, () => {
+      const attr = self.string(value);
+      if (options.notNullable) {
+        attr.notNullable();
+      }
+      return attr;
+    });
+  };
+}
+
+function Num(value, options = {}) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(propertyKey, () => {
+      const attr = self.number(value);
+      if (options.notNullable) {
+        attr.notNullable();
+      }
+      return attr;
+    });
+  };
+}
+
+function Bool(value, options = {}) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(propertyKey, () => {
+      const attr = self.boolean(value);
+      if (options.notNullable) {
+        attr.notNullable();
+      }
+      return attr;
+    });
+  };
+}
+
+function Uid(options) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(propertyKey, () => self.uid(options));
+  };
+}
+
+function HasOne(related, foreignKey, localKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.hasOne(related(), foreignKey, localKey)
+    );
+  };
+}
+
+function BelongsTo(related, foreignKey, ownerKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.belongsTo(related(), foreignKey, ownerKey)
+    );
+  };
+}
+
+function BelongsToMany(related, pivot, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.belongsToMany(related(), pivot(), foreignPivotKey, relatedPivotKey, parentKey, relatedKey)
+    );
+  };
+}
+
+function HasMany(related, foreignKey, localKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.hasMany(related(), foreignKey, localKey)
+    );
+  };
+}
+
+function HasManyBy(related, foreignKey, ownerKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.hasManyBy(related(), foreignKey, ownerKey)
+    );
+  };
+}
+
+function HasManyThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.hasManyThrough(related(), through(), firstKey, secondKey, localKey, secondLocalKey)
+    );
+  };
+}
+
+function MorphOne(related, id, type, localKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.morphOne(related(), id, type, localKey)
+    );
+  };
+}
+
+function MorphTo(related, id, type, ownerKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.morphTo(related(), id, type, ownerKey)
+    );
+  };
+}
+
+function MorphToMany(related, pivot, relatedId, id, type, parentKey, relatedKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.morphToMany(related(), pivot(), relatedId, id, type, parentKey, relatedKey)
+    );
+  };
+}
+
+function MorphMany(related, id, type, localKey) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setRegistry(
+      propertyKey,
+      () => self.morphMany(related(), id, type, localKey)
+    );
+  };
+}
+
+function OnDelete(mode) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setFieldDeleteMode(propertyKey, mode);
+  };
+}
+
+function Cast(to) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setCast(propertyKey, to());
+  };
+}
+
+function Mutate(get, set) {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setMutator(propertyKey, { get, set });
+  };
+}
+
+function Hidden() {
+  return (target, propertyKey) => {
+    const self = target.$self();
+    self.setHidden(propertyKey);
+  };
+}
+
+function NonEnumerable(target, propertyKey) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, propertyKey) || /* @__PURE__ */ Object.create(null);
+  if (descriptor.enumerable !== false) {
+    Object.defineProperty(target, propertyKey, {
+      enumerable: false,
+      set(value) {
+        Object.defineProperty(this, propertyKey, {
+          enumerable: false,
+          writable: true,
+          value
+        });
+      }
+    });
+  }
+}
+
+export { Attr, BelongsTo, BelongsToMany, Bool, Cast, HasMany, HasManyBy, HasManyThrough, HasOne, Hidden, MorphMany, MorphOne, MorphTo, MorphToMany, Mutate, NonEnumerable, Num, OnDelete, Str, Uid };

package/dist/helpers.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+const Utils = require('./shared/pinia-orm.a62c4fc4.cjs');
+
+function useSum(models, field) {
+  return models.reduce((sum, item) => {
+    if (typeof item[field] === "number") {
+      sum += item[field];
+    }
+    return sum;
+  }, 0);
+}
+
+function usePluck(models, field) {
+  return models.map((model) => Utils.getValue(model, field)).filter((item) => item);
+}
+
+function useMax(models, field) {
+  const numbers = usePluck(models, field).filter((item) => typeof item === "number");
+  return numbers.length === 0 ? 0 : Math.max(...numbers);
+}
+
+function useMin(models, field) {
+  const numbers = usePluck(models, field).filter((item) => typeof item === "number");
+  return numbers.length === 0 ? 0 : Math.min(...numbers);
+}
+
+function useKeys(models) {
+  return models.map((model) => model[model.$getLocalKey()]);
+}
+
+function useGroupBy(models, fields) {
+  const grouped = {};
+  const props = Array.isArray(fields) ? fields : [fields];
+  models.forEach((model) => {
+    const key = props.length === 1 ? model[props[0]] : `[${props.map((field) => model[field]).toString()}]`;
+    grouped[key] = (grouped[key] || []).concat(model);
+  });
+  return grouped;
+}
+
+function useSortBy(collection, sort, flags) {
+  const directions = [];
+  const iteratees = [];
+  typeof sort === "function" && iteratees.push(sort) && directions.push("asc");
+  Array.isArray(sort) && sort.forEach((item) => iteratees.push(item[0]) && directions.push(item[1]));
+  iteratees.length === 0 && iteratees.push(sort);
+  return Utils.orderBy(collection, iteratees, directions, flags);
+}
+
+function useCollect(models) {
+  return {
+    sum: (field) => useSum(models, field),
+    min: (field) => useMin(models, field),
+    max: (field) => useMax(models, field),
+    pluck: (field) => usePluck(models, field),
+    groupBy: (fields) => useGroupBy(models, fields),
+    sortBy: (sort, flags = "SORT_REGULAR") => useSortBy(models, sort, flags),
+    keys: () => useKeys(models)
+  };
+}
+
+exports.useCollect = useCollect;
+exports.useGroupBy = useGroupBy;
+exports.useKeys = useKeys;
+exports.useMax = useMax;
+exports.useMin = useMin;
+exports.usePluck = usePluck;
+exports.useSum = useSum;

package/dist/helpers.d.cts

@@ -0,0 +1,54 @@
+import { M as Model, b as Collection } from './shared/pinia-orm.876a7cdc.cjs';
+import 'pinia';
+import '@pinia-orm/normalizr';
+import '@/composables';
+
+type SortFlags = 'SORT_REGULAR' | 'SORT_FLAG_CASE';
+
+type sorting<T> = ((record: T) => any) | string | [string, 'asc' | 'desc'][];
+
+interface UseCollect<M extends Model = Model> {
+    sum: (field: string) => number;
+    min: (field: string) => number;
+    max: (field: string) => number;
+    pluck: (field: string) => any[];
+    groupBy: (fields: string[] | string) => Record<string, Collection<M>>;
+    sortBy: (sort: sorting<M>, flags?: SortFlags) => M[];
+    keys: () => string[];
+}
+/**
+ * Return all possible helper functions for the collection
+ */
+declare function useCollect<M extends Model = Model>(models: Collection<M>): UseCollect<M>;
+
+/**
+ * Get the sum value of the specified filed.
+ */
+declare function useSum(models: Collection, field: string): number;
+
+/**
+ * The useGroupBy method groups the collection's items by a given key.
+ */
+declare function useGroupBy<T extends Record<string, any>>(models: T[], fields: string[] | string): Record<string, T[]>;
+
+/**
+ * The keys method returns all of the collection's primary keys
+ */
+declare function useKeys(models: Collection): string[];
+
+/**
+ * Get the min value of the specified filed.
+ */
+declare function useMin(models: Collection, field: string): number;
+
+/**
+ * Get the max value of the specified filed.
+ */
+declare function useMax(models: Collection, field: string): number;
+
+/**
+ * The pluck method retrieves all of the values for a given key.
+ */
+declare function usePluck(models: Collection, field: string): any[];
+
+export { type UseCollect, useCollect, useGroupBy, useKeys, useMax, useMin, usePluck, useSum };

package/dist/helpers.d.mts

@@ -0,0 +1,54 @@
+import { M as Model, b as Collection } from './shared/pinia-orm.876a7cdc.mjs';
+import 'pinia';
+import '@pinia-orm/normalizr';
+import '@/composables';
+
+type SortFlags = 'SORT_REGULAR' | 'SORT_FLAG_CASE';
+
+type sorting<T> = ((record: T) => any) | string | [string, 'asc' | 'desc'][];
+
+interface UseCollect<M extends Model = Model> {
+    sum: (field: string) => number;
+    min: (field: string) => number;
+    max: (field: string) => number;
+    pluck: (field: string) => any[];
+    groupBy: (fields: string[] | string) => Record<string, Collection<M>>;
+    sortBy: (sort: sorting<M>, flags?: SortFlags) => M[];
+    keys: () => string[];
+}
+/**
+ * Return all possible helper functions for the collection
+ */
+declare function useCollect<M extends Model = Model>(models: Collection<M>): UseCollect<M>;
+
+/**
+ * Get the sum value of the specified filed.
+ */
+declare function useSum(models: Collection, field: string): number;
+
+/**
+ * The useGroupBy method groups the collection's items by a given key.
+ */
+declare function useGroupBy<T extends Record<string, any>>(models: T[], fields: string[] | string): Record<string, T[]>;
+
+/**
+ * The keys method returns all of the collection's primary keys
+ */
+declare function useKeys(models: Collection): string[];
+
+/**
+ * Get the min value of the specified filed.
+ */
+declare function useMin(models: Collection, field: string): number;
+
+/**
+ * Get the max value of the specified filed.
+ */
+declare function useMax(models: Collection, field: string): number;
+
+/**
+ * The pluck method retrieves all of the values for a given key.
+ */
+declare function usePluck(models: Collection, field: string): any[];
+
+export { type UseCollect, useCollect, useGroupBy, useKeys, useMax, useMin, usePluck, useSum };

package/dist/helpers.d.ts

@@ -0,0 +1,54 @@
+import { M as Model, b as Collection } from './shared/pinia-orm.876a7cdc.js';
+import 'pinia';
+import '@pinia-orm/normalizr';
+import '@/composables';
+
+type SortFlags = 'SORT_REGULAR' | 'SORT_FLAG_CASE';
+
+type sorting<T> = ((record: T) => any) | string | [string, 'asc' | 'desc'][];
+
+interface UseCollect<M extends Model = Model> {
+    sum: (field: string) => number;
+    min: (field: string) => number;
+    max: (field: string) => number;
+    pluck: (field: string) => any[];
+    groupBy: (fields: string[] | string) => Record<string, Collection<M>>;
+    sortBy: (sort: sorting<M>, flags?: SortFlags) => M[];
+    keys: () => string[];
+}
+/**
+ * Return all possible helper functions for the collection
+ */
+declare function useCollect<M extends Model = Model>(models: Collection<M>): UseCollect<M>;
+
+/**
+ * Get the sum value of the specified filed.
+ */
+declare function useSum(models: Collection, field: string): number;
+
+/**
+ * The useGroupBy method groups the collection's items by a given key.
+ */
+declare function useGroupBy<T extends Record<string, any>>(models: T[], fields: string[] | string): Record<string, T[]>;
+
+/**
+ * The keys method returns all of the collection's primary keys
+ */
+declare function useKeys(models: Collection): string[];
+
+/**
+ * Get the min value of the specified filed.
+ */
+declare function useMin(models: Collection, field: string): number;
+
+/**
+ * Get the max value of the specified filed.
+ */
+declare function useMax(models: Collection, field: string): number;
+
+/**
+ * The pluck method retrieves all of the values for a given key.
+ */
+declare function usePluck(models: Collection, field: string): any[];
+
+export { type UseCollect, useCollect, useGroupBy, useKeys, useMax, useMin, usePluck, useSum };

package/dist/helpers.mjs

@@ -0,0 +1,61 @@
+import { k as getValue, o as orderBy } from './shared/pinia-orm.1bd7d299.mjs';
+
+function useSum(models, field) {
+  return models.reduce((sum, item) => {
+    if (typeof item[field] === "number") {
+      sum += item[field];
+    }
+    return sum;
+  }, 0);
+}
+
+function usePluck(models, field) {
+  return models.map((model) => getValue(model, field)).filter((item) => item);
+}
+
+function useMax(models, field) {
+  const numbers = usePluck(models, field).filter((item) => typeof item === "number");
+  return numbers.length === 0 ? 0 : Math.max(...numbers);
+}
+
+function useMin(models, field) {
+  const numbers = usePluck(models, field).filter((item) => typeof item === "number");
+  return numbers.length === 0 ? 0 : Math.min(...numbers);
+}
+
+function useKeys(models) {
+  return models.map((model) => model[model.$getLocalKey()]);
+}
+
+function useGroupBy(models, fields) {
+  const grouped = {};
+  const props = Array.isArray(fields) ? fields : [fields];
+  models.forEach((model) => {
+    const key = props.length === 1 ? model[props[0]] : `[${props.map((field) => model[field]).toString()}]`;
+    grouped[key] = (grouped[key] || []).concat(model);
+  });
+  return grouped;
+}
+
+function useSortBy(collection, sort, flags) {
+  const directions = [];
+  const iteratees = [];
+  typeof sort === "function" && iteratees.push(sort) && directions.push("asc");
+  Array.isArray(sort) && sort.forEach((item) => iteratees.push(item[0]) && directions.push(item[1]));
+  iteratees.length === 0 && iteratees.push(sort);
+  return orderBy(collection, iteratees, directions, flags);
+}
+
+function useCollect(models) {
+  return {
+    sum: (field) => useSum(models, field),
+    min: (field) => useMin(models, field),
+    max: (field) => useMax(models, field),
+    pluck: (field) => usePluck(models, field),
+    groupBy: (fields) => useGroupBy(models, fields),
+    sortBy: (sort, flags = "SORT_REGULAR") => useSortBy(models, sort, flags),
+    keys: () => useKeys(models)
+  };
+}
+
+export { useCollect, useGroupBy, useKeys, useMax, useMin, usePluck, useSum };