@arcote.tech/arc 0.0.12 → 0.0.13

package/dist/collection/collection.d.ts

@@ -15,7 +15,8 @@ declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema ext
     readonly name: Name;
     readonly id: Id;
     readonly schema: Schema;
-    constructor(name: Name, id: Id, schema: Schema);
+    readonly options: ArcCollectionOptions<Id, Schema>;
+    constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>);
     serialize(data: objectUtil.simplify<{
         _id: util.FirstArgument<Id["serialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): objectUtil.simplify<{
@@ -45,7 +46,7 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
     [name: string]: Indexes[];
 }> extends ArcCollection<Name, Id, Schema> implements ArcContextElement {
     readonly indexes: I;
-    constructor(name: Name, id: Id, schema: Schema, indexes: I);
+    constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>, indexes: I);
     queryBuilder(): {
         all: () => ArcAllItemsQueryBuilder<ArcCollection<Name, Id, Schema>>;
         one: (id: util.GetType<Id> | undefined) => ArcOneItemQueryBuilder<ArcCollection<Name, Id, Schema>>;
@@ -57,5 +58,8 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
 }
 export type ArcCollectionAny = ArcCollection<any, any, any>;
 export type ArcIndexedCollectionAny = ArcIndexedCollection<any, any, any, any, any>;
-export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema): ArcCollection<Name, Id, Schema>;
+type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    sort?: (a: Deserialize<Id, Schema>, b: Deserialize<Id, Schema>) => number;
+};
+export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema, options?: ArcCollectionOptions<Id, Schema>): ArcCollection<Name, Id, Schema>;
 export {};

package/dist/collection/query-builders/abstract-many-items.d.ts

@@ -1,9 +1,11 @@
 import { ArcQueryBuilder } from "../../context/query-builders";
 import type { util } from "../../utils";
 import { type ArcCollectionAny } from "../collection";
+type SortComparator<C extends ArcCollectionAny> = ((a: util.CollectionItemWithId<C>, b: util.CollectionItemWithId<C>) => number) | Array<[keyof util.CollectionItemWithId<C>, "ASC" | "DESC"]>;
 export declare abstract class ArcManyItemsQueryBuilder<C extends ArcCollectionAny> extends ArcQueryBuilder {
     protected filterFn?: (item: util.CollectionItemWithId<C>) => boolean;
     protected sortFn?: (a: util.CollectionItemWithId<C>, b: util.CollectionItemWithId<C>) => number;
     filter(callback: (item: util.CollectionItemWithId<C>) => boolean): this;
-    sort(callback: (a: util.CollectionItemWithId<C>, b: util.CollectionItemWithId<C>) => number): this;
+    sort(comparator: SortComparator<C>): this;
 }
+export {};

package/dist/elements/instanceOf.d.ts

@@ -0,0 +1,19 @@
+import type { ArcElement } from "./element";
+import type { ArcRawShape } from "./object";
+import { ArcOptional } from "./optional";
+export declare function ArcClass<E extends ArcRawShape>(shape: E): {
+    new (): { [key in keyof E]: ReturnType<E[key]["deserialize"]>; };
+};
+export declare class ArcInstanceOf<E> implements ArcElement {
+    private Class;
+    constructor(Class: {
+        new (): E;
+    });
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): E;
+    parse(value: unknown): unknown;
+    optional(): ArcOptional<this>;
+}
+export declare function instanceOf<E>(element: {
+    new (): E;
+}): ArcInstanceOf<E>;

package/dist/elements/or.d.ts

@@ -0,0 +1,11 @@
+import type { util } from "../utils";
+import type { ArcElement } from "./element";
+export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
+    private elements;
+    constructor(elements: T);
+    serialize(value: util.FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
+    deserialize(value: util.FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
+    parse(value: util.FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
+    private isTypeOf;
+}
+export declare function or<T extends ArcElement[]>(...elements: T): ArcOr<T>;

package/dist/elements/recurent.d.ts

@@ -0,0 +1,20 @@
+import { type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+import type { ArcElement } from "./element";
+import { ArcOptional } from "./optional";
+export declare class ArcRecurent<E extends ArcElement, Brand extends string | symbol> implements ArcElement {
+    private parent;
+    constructor(parent: E);
+    serialize(value: util.FirstArgument<E["serialize"]> & {
+        __brand: Brand;
+    }): ReturnType<E["serialize"]>;
+    deserialize(value: util.FirstArgument<E["deserialize"]>): ReturnType<E["deserialize"]> & {
+        __brand: Brand;
+    };
+    parse(value: util.FirstArgument<E["parse"]>): ReturnType<E["parse"]> & {
+        __brand: Brand;
+    };
+    optional(): ArcOptional<this>;
+}
+export type ArcRecurentAny = ArcRecurent<ArcAbstract, any>;
+export declare function recurent<E extends () => ArcElement>(element: E): ArcRecurent<ArcElement, string | symbol>;

package/dist/index.js

@@ -114,6 +114,23 @@ class ArcQueryBuilder {
 }
 
 // collection/query-builders/abstract-many-items.ts
+function sortComparatorBuilder(comparator) {
+  if (typeof comparator === "function") {
+    return comparator;
+  } else if (Array.isArray(comparator)) {
+    return (a, b) => {
+      for (const [key, order] of comparator) {
+        if (a[key] < b[key])
+          return order === "ASC" ? -1 : 1;
+        if (a[key] > b[key])
+          return order === "ASC" ? 1 : -1;
+      }
+      return 0;
+    };
+  }
+  throw new Error("Invalid comparator type");
+}
+
 class ArcManyItemsQueryBuilder extends ArcQueryBuilder {
   filterFn;
   sortFn;
@@ -121,8 +138,8 @@ class ArcManyItemsQueryBuilder extends ArcQueryBuilder {
     this.filterFn = callback;
     return this;
   }
-  sort(callback) {
-    this.sortFn = callback;
+  sort(comparator) {
+    this.sortFn = sortComparatorBuilder(comparator);
     return this;
   }
 }
@@ -133,6 +150,8 @@ class ArcAllItemsQueryBuilder extends ArcManyItemsQueryBuilder {
   constructor(collection) {
     super();
     this.collection = collection;
+    if (collection.options.sort)
+      this.sortFn = collection.options.sort;
   }
   toQuery() {
     return new ArcAllItemsQuery(this.collection, this.filterFn, this.sortFn);
@@ -175,6 +194,8 @@ class ArcIndexedItemsQueryBuilder extends ArcManyItemsQueryBuilder {
     this.collection = collection;
     this.index = index;
     this.data = data;
+    if (collection.options.sort)
+      this.sortFn = collection.options.sort;
   }
   toQuery() {
     return new ArcIndexedItemsQuery(this.collection, this.index, this.data, this.filterFn, this.sortFn);
@@ -217,18 +238,20 @@ class ArcOneItemQueryBuilder extends ArcQueryBuilder {
 }
 
 // collection/collection.ts
-function collection(name, id, schema) {
-  return new ArcCollection(name, id, schema);
+function collection(name, id, schema, options = {}) {
+  return new ArcCollection(name, id, schema, options);
 }
 
 class ArcCollection {
   name;
   id;
   schema;
-  constructor(name, id, schema) {
+  options;
+  constructor(name, id, schema, options) {
     this.name = name;
     this.id = id;
     this.schema = schema;
+    this.options = options;
   }
   serialize(data) {
     return {
@@ -304,14 +327,14 @@ class ArcCollection {
     }
   }
   indexBy(indexes) {
-    return new ArcIndexedCollection(this.name, this.id, this.schema, indexes);
+    return new ArcIndexedCollection(this.name, this.id, this.schema, this.options, indexes);
   }
 }
 
 class ArcIndexedCollection extends ArcCollection {
   indexes;
-  constructor(name, id, schema, indexes) {
-    super(name, id, schema);
+  constructor(name, id, schema, options, indexes) {
+    super(name, id, schema, options);
     this.indexes = indexes;
   }
   queryBuilder() {

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",