@arcote.tech/arc 0.0.27 → 0.1.2

package/dist/elements/date.d.ts

@@ -1,9 +1,42 @@
 import { ArcAbstract } from "./abstract";
-export declare class ArcDate extends ArcAbstract<[]> {
+import type { CheckFn, GetValidator, Validators } from "./abstract";
+declare const dateValidator: {
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "Date";
+    };
+};
+export declare class ArcDate<V extends Validators = [typeof dateValidator]> extends ArcAbstract<V> {
     constructor();
     parse(value: string | number | Date): Date;
     serialize(value: Date): number;
     deserialize(value: string): Date;
+    after(after: Date): ArcDate<[...V, {
+        name: "after";
+        validator: (value: any) => {
+            current: any;
+            after: Date;
+        } | undefined;
+    }]>;
+    before(before: Date): ArcDate<[...V, {
+        name: "before";
+        validator: (value: any) => {
+            current: any;
+            before: Date;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcDate<GetValidator<ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
 }
-export declare function date(): ArcDate;
+export declare function date(): ArcDate<[{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "Date";
+    };
+}]>;
+export {};
 //# sourceMappingURL=date.d.ts.map

package/dist/elements/index.d.ts

@@ -1,11 +1,13 @@
 export * from "./array";
 export * from "./boolean";
 export * from "./branded";
+export * from "./class";
 export * from "./date";
 export * from "./id";
 export * from "./number";
 export * from "./object";
 export * from "./optional";
+export * from "./or";
 export * from "./record";
 export * from "./string";
 export * from "./string-enum";

package/dist/elements/number.d.ts

@@ -1,17 +1,25 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcNumber<V extends Validators = []> extends ArcPrimitive<V, number> {
+declare const numberValidator: {
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "number";
+    };
+};
+export declare class ArcNumber<V extends Validators = [typeof numberValidator]> extends ArcPrimitive<V, number> {
+    constructor();
     min(min: number): ArcNumber<[...V, {
         name: "min";
-        validator: (value: any) => {
-            current: any;
+        validator: (value: number) => {
+            current: number;
             min: number;
         } | undefined;
     }]>;
     max(max: number): ArcNumber<[...V, {
         name: "max";
-        validator: (value: any) => {
-            current: any;
+        validator: (value: number) => {
+            current: number;
             max: number;
         } | undefined;
     }]>;
@@ -20,5 +28,12 @@ export declare class ArcNumber<V extends Validators = []> extends ArcPrimitive<V
         validator: Fn;
     }]>>>;
 }
-export declare function number(): ArcNumber<[]>;
+export declare function number(): ArcNumber<[{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "number";
+    };
+}]>;
+export {};
 //# sourceMappingURL=number.d.ts.map

package/dist/elements/object.d.ts

@@ -1,10 +1,25 @@
-import { objectUtil, type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { type objectUtil, type util } from "../utils";
+import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
 export declare type ArcRawShape = {
     [k: string]: ArcElement;
 };
-export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract<[]> {
+declare const objectValidator: {
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "object";
+    };
+};
+export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
+    typeof objectValidator,
+    {
+        name: "schema";
+        validator: (value: any) => {
+            [key in keyof E]: ReturnType<E[key]["validate"]>;
+        } | false;
+    }
+]> extends ArcAbstract<V> {
     private rawShape;
     constructor(rawShape: E);
     parse(value: {
@@ -38,13 +53,25 @@ export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract<[]> {
     }>): {
         [key in keyof E]: ReturnType<E[key]["serialize"]>;
     };
-    pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>>;
-    validate(value: any): {
-        [key in keyof E]: ReturnType<E[key]["validate"]>;
-    };
+    pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>, V>;
+    omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
+    entries(): [string, ArcElement][];
 }
-export type ArcObjectAny = ArcObject<any>;
-export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E> ? Exclude<keyof E, symbol> : never;
-export type ArcObjectValueByKey<T extends ArcObjectAny, K extends ArcObjectKeys<T>> = T extends ArcObject<infer E> ? E[K] : never;
-export declare function object<E extends ArcRawShape>(element: E): ArcObject<E>;
+export type ArcObjectAny = ArcObject<any, any>;
+export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E, any> ? Exclude<keyof E, symbol> : never;
+export type ArcObjectValueByKey<T extends ArcObjectAny, K extends ArcObjectKeys<T>> = T extends ArcObject<infer E, any> ? E[K] : never;
+export type ArcRawShapeType<Shape extends ArcRawShape> = {
+    [key in keyof Shape]: ReturnType<Shape[key]["deserialize"]>;
+} & {};
+export declare function object<E extends ArcRawShape>(element: E): ArcObject<E, [{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "object";
+    };
+}, {
+    name: "schema";
+    validator: (value: any) => false | { [key in keyof E]: ReturnType<E[key]["validate"]>; };
+}]>;
+export {};
 //# sourceMappingURL=object.d.ts.map

package/dist/elements/or.d.ts

@@ -1,12 +1,2 @@
-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>;
+export {};
 //# sourceMappingURL=or.d.ts.map

package/dist/elements/record.d.ts

@@ -1,11 +1,18 @@
 import { type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
 import type { ArcId } from "./id";
 import type { ArcNumber } from "./number";
 import type { ArcString } from "./string";
-type ArcKey = ArcString | ArcNumber | ArcId<any>;
-export declare class ArcRecord<Key extends ArcKey, E extends ArcElement> extends ArcAbstract<[]> {
+type ArcKey = ArcString<any> | ArcNumber | ArcId<any>;
+export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V extends Validators = [
+    {
+        name: "schema";
+        validator: (value: any) => {
+            [index: string]: ReturnType<E["validate"]>;
+        } | false;
+    }
+]> extends ArcAbstract<V> {
     private key;
     private element;
     constructor(key: Key, element: E);
@@ -14,6 +21,11 @@ export declare class ArcRecord<Key extends ArcKey, E extends ArcElement> extends
     deserialize(value: Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>): Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>;
 }
 export type ArcRecordAny = ArcRecord<any, any>;
-export declare function record<Key extends ArcKey, E extends ArcElement>(key: Key, element: E): ArcRecord<Key, E>;
+export declare function record<Key extends ArcKey, E extends ArcElement>(key: Key, element: E): ArcRecord<Key, E, [{
+    name: "schema";
+    validator: (value: any) => false | {
+        [index: string]: ReturnType<E["validate"]>;
+    };
+}]>;
 export {};
 //# sourceMappingURL=record.d.ts.map

package/dist/elements/string-enum.d.ts

@@ -1,5 +1,13 @@
-import { ArcAbstract } from "./abstract";
-export declare class ArcStringEnum<const T extends string[]> extends ArcAbstract<[]> {
+import { ArcAbstract, type Validators } from "./abstract";
+export declare class ArcStringEnum<const T extends string[], V extends Validators = [
+    {
+        name: "schema";
+        validator: (value: string) => {
+            expect: T;
+            current: string;
+        } | false;
+    }
+]> extends ArcAbstract<V> {
     private values;
     constructor(values: T);
     parse<Value extends T[number]>(value: Value): Value;
@@ -8,5 +16,11 @@ export declare class ArcStringEnum<const T extends string[]> extends ArcAbstract
     getEnumerators(): T;
 }
 export type ArcStringEnumAny = ArcStringEnum<any>;
-export declare function stringEnum<const T extends string[]>(...values: T): ArcStringEnum<T>;
+export declare function stringEnum<const T extends string[]>(...values: T): ArcStringEnum<T, [{
+    name: "schema";
+    validator: (value: string) => false | {
+        expect: T;
+        current: string;
+    };
+}]>;
 //# sourceMappingURL=string-enum.d.ts.map

package/dist/elements/string.d.ts

@@ -1,24 +1,92 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcString<V extends Validators = []> extends ArcPrimitive<V, string> {
+declare const stringValidator: {
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "string";
+    };
+};
+export declare class ArcString<V extends Validators = [typeof stringValidator]> extends ArcPrimitive<V, string> {
+    constructor();
     minLength(min: number): ArcString<[...V, {
         name: "minLength";
-        validator: (value: any) => {
-            currentLength: any;
+        validator: (value: string) => {
+            currentLength: number;
             minLength: number;
         } | undefined;
     }]>;
     maxLength(max: number): ArcString<[...V, {
         name: "maxLength";
-        validator: (value: any) => {
-            currentLength: any;
+        validator: (value: string) => {
+            currentLength: number;
             maxLength: number;
         } | undefined;
     }]>;
+    length(number: number): ArcString<[...V, {
+        name: "length";
+        validator: (value: string) => {
+            currentLength: number;
+            length: number;
+        } | undefined;
+    }]>;
+    includes(str: string): ArcString<[...V, {
+        name: "includes";
+        validator: (value: string) => {
+            currentValue: string;
+            includes: string;
+        } | undefined;
+    }]>;
+    startsWith(str: string): ArcString<[...V, {
+        name: "startsWith";
+        validator: (value: string) => {
+            currentValue: string;
+            startsWith: string;
+        } | undefined;
+    }]>;
+    endsWith(str: string): ArcString<[...V, {
+        name: "endsWith";
+        validator: (value: string) => {
+            currentValue: string;
+            endsWith: string;
+        } | undefined;
+    }]>;
+    regex(regex: RegExp): ArcString<[...V, {
+        name: "regex";
+        validator: (value: string) => {
+            currentValue: string;
+            regex: RegExp;
+        } | undefined;
+    }]>;
+    email(): ArcString<[...V, {
+        name: "email";
+        validator: (value: string) => {
+            currentEmail: string;
+        } | undefined;
+    }]>;
+    url(): ArcString<[...V, {
+        name: "url";
+        validator: (value: string) => {
+            currentUrl: string;
+        } | undefined;
+    }]>;
+    ip(): ArcString<[...V, {
+        name: "ip";
+        validator: (value: string) => {
+            currentIP: string;
+        } | undefined;
+    }]>;
     validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcString<GetValidator<import("./abstract").ArcAbstract<[...V, {
         name: Name;
         validator: Fn;
     }]>>>;
 }
-export declare function string(): ArcString<[]>;
+export declare function string(): ArcString<[{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "string";
+    };
+}]>;
+export {};
 //# sourceMappingURL=string.d.ts.map

package/dist/elements/utils/type-validator-builder.d.ts

@@ -0,0 +1,8 @@
+export declare function typeValidatorBuilder<TypeName extends string>(typeName: TypeName, comparatorStrategy?: (value: any) => boolean): {
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: TypeName;
+    };
+};
+//# sourceMappingURL=type-validator-builder.d.ts.map

package/dist/index.d.ts

@@ -1,9 +1,12 @@
 export * from "./collection";
+export * from "./command";
 export * from "./context";
 export * from "./data-storage";
 export * from "./db";
 export * from "./elements";
+export * from "./model";
 export * from "./rtc";
 export * from "./state";
 export * from "./utils";
+export * from "./view/view";
 //# sourceMappingURL=index.d.ts.map