@arcote.tech/arc 0.0.26 → 0.1.0

package/dist/elements/boolean.d.ts

@@ -1,5 +1,5 @@
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcBoolean extends ArcPrimitive<boolean> {
+export declare class ArcBoolean extends ArcPrimitive<[], boolean> {
 }
 export declare function boolean(): ArcBoolean;
 //# sourceMappingURL=boolean.d.ts.map

package/dist/elements/branded.d.ts

@@ -1,8 +1,8 @@
 import { type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
 import { ArcOptional } from "./optional";
-export declare class ArcBranded<E extends ArcAbstract, Brand extends string | symbol> implements ArcElement {
+export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string | symbol> implements ArcElement {
     private parent;
     private brand;
     constructor(parent: E, brand: Brand);
@@ -16,6 +16,7 @@ export declare class ArcBranded<E extends ArcAbstract, Brand extends string | sy
         __brand: Brand;
     };
     optional(): ArcOptional<this>;
+    validate(value: unknown): unknown;
 }
-export type ArcBrandedAny = ArcBranded<ArcAbstract, any>;
+export type ArcBrandedAny = ArcBranded<ArcAbstractAny, any>;
 //# sourceMappingURL=branded.d.ts.map

package/dist/elements/class.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=class.d.ts.map

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/default.d.ts

@@ -4,6 +4,7 @@ export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     private parent;
     private defaultValueOrCallback;
     constructor(parent: E, defaultValueOrCallback: (() => ReturnType<E["deserialize"]>) | ReturnType<E["deserialize"]>);
+    validate(value: unknown): unknown;
     parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
     serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
     deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;

package/dist/elements/element.d.ts

@@ -2,5 +2,6 @@ export interface ArcElement {
     serialize(value: unknown): unknown;
     deserialize(value: unknown): unknown;
     parse(value: unknown): unknown;
+    validate(value: unknown): unknown;
 }
 //# sourceMappingURL=element.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,5 +1,39 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcNumber extends ArcPrimitive<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: number) => {
+            current: number;
+            min: number;
+        } | undefined;
+    }]>;
+    max(max: number): ArcNumber<[...V, {
+        name: "max";
+        validator: (value: number) => {
+            current: number;
+            max: number;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcNumber<GetValidator<import("./abstract").ArcAbstract<[...V, {
+        name: Name;
+        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,7 +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>, V>;
+    omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
+    entries(): [string, ArcElement][];
 }
-export type ArcObjectAny = ArcObject<any>;
-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/optional.d.ts

@@ -1,5 +1,5 @@
 import { type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
 export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     private parent;
@@ -7,6 +7,7 @@ export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     parse(value: util.FirstArgument<E["parse"]> | null | undefined): ReturnType<E["parse"]> | null;
     serialize(value: util.FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
     deserialize(value: util.FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
+    validate(value: unknown): unknown;
 }
-export type ArcOptionalAny = ArcOptional<ArcAbstract>;
+export type ArcOptionalAny = ArcOptional<ArcAbstractAny>;
 //# sourceMappingURL=optional.d.ts.map

package/dist/elements/or.d.ts

@@ -0,0 +1,2 @@
+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,5 +1,92 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcString extends ArcPrimitive<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: string) => {
+            currentLength: number;
+            minLength: number;
+        } | undefined;
+    }]>;
+    maxLength(max: number): ArcString<[...V, {
+        name: "maxLength";
+        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/tests/example.d.ts

@@ -0,0 +1,6 @@
+export declare const instanceof_parse: (value: {
+    test: string;
+}) => {
+    test: string;
+};
+//# sourceMappingURL=example.d.ts.map

package/dist/elements/tests/test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test.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