@idb-orm/core 1.0.11 → 1.0.13

package/dist/typing/tag.d.ts

@@ -0,0 +1,104 @@
+import { MaybeGenerator, Promisable } from '../util-types';
+export declare const enum Tag {
+    string = 0,
+    number = 1,
+    date = 2,
+    boolean = 3,
+    symbol = 4,
+    bigint = 5,
+    file = 6,
+    void = 7,
+    float = 8,
+    int = 9,
+    unknown = 10,
+    literal = 11,
+    array = 12,
+    set = 13,
+    union = 14,
+    optional = 15,
+    default = 16,
+    object = 17,
+    tuple = 18,
+    custom = 19
+}
+export interface VoidTag {
+    tag: Tag.void;
+}
+export interface StringTag {
+    tag: Tag.string;
+}
+export interface NumberTag {
+    tag: Tag.number;
+}
+export interface IntTag {
+    tag: Tag.int;
+}
+export interface FloatTag {
+    tag: Tag.float;
+}
+export interface DateTag {
+    tag: Tag.date;
+}
+export interface BooleanTag {
+    tag: Tag.boolean;
+}
+export interface SymbolTag {
+    tag: Tag.symbol;
+}
+export interface BigIntTag {
+    tag: Tag.bigint;
+}
+export interface UnknownTag {
+    tag: Tag.unknown;
+}
+export interface FileTag {
+    tag: Tag.file;
+}
+export interface LiteralTag<V = unknown> {
+    tag: Tag.literal;
+    value: V;
+}
+export interface ArrayTag<V extends TypeTag = TypeTag> {
+    tag: Tag.array;
+    of: V;
+}
+export interface SetTag<V extends TypeTag = TypeTag> {
+    tag: Tag.set;
+    of: V;
+}
+export interface OptionalTag<V extends TypeTag = TypeTag> {
+    tag: Tag.optional;
+    of: V;
+}
+export interface UnionTag<V extends TypeTag[] = TypeTag[]> {
+    tag: Tag.union;
+    options: V;
+}
+export interface TupleTag<V extends TypeTag[] = TypeTag[]> {
+    tag: Tag.tuple;
+    elements: V;
+}
+export interface ObjectTag<P extends Record<string, TypeTag> = Record<string, TypeTag>> {
+    tag: Tag.object;
+    props: P;
+}
+export interface DefaultTag<T extends TypeTag = TypeTag> {
+    tag: Tag.default;
+    of: T;
+    value: MaybeGenerator<unknown>;
+}
+export interface CustomTag<V = any, PR = any> {
+    tag: Tag.custom;
+    isType: (test: unknown) => boolean;
+    parse?: (test: unknown) => PR;
+    serialize?: (value: V) => Promisable<unknown>;
+    deserialize?: (value: unknown) => Promisable<V>;
+}
+type Dec = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+export type TypeTag = VoidTag | LiteralTag | StringTag | IntTag | FloatTag | NumberTag | DateTag | BooleanTag | SymbolTag | UnknownTag | FileTag | BigIntTag | SetTag | OptionalTag | UnionTag | ArrayTag | ObjectTag | TupleTag | CustomTag | DefaultTag;
+export type TagToType<T extends TypeTag, Depth extends number = 5> = Depth extends 0 ? any : T extends StringTag ? string : T extends NumberTag ? number : T extends BooleanTag ? boolean : T extends LiteralTag<infer V> ? V : T extends DateTag ? Date : T extends SymbolTag ? symbol : T extends UnknownTag ? unknown : T extends FileTag ? File : T extends BigIntTag ? bigint : T extends TupleTag<infer TEls> ? {
+    [K in keyof TEls]: TagToType<TEls[K], Dec[Depth]>;
+} : T extends SetTag<infer T> ? Set<TagToType<T, Dec[Depth]>> : T extends UnionTag<infer TOpts> ? TagToType<TOpts[number], Dec[Depth]> : T extends ArrayTag<infer T> ? TagToType<T, Dec[Depth]>[] : T extends ObjectTag<infer P> ? {
+    [K in keyof P]: TagToType<P[K], Dec[Depth]>;
+} : T extends DefaultTag<infer T> | OptionalTag<infer T> ? TagToType<T, Dec[Depth]> | undefined : T extends CustomTag<infer V> ? V : never;
+export {};

package/dist/typing/type.d.ts

@@ -0,0 +1,42 @@
+import { Literable } from '../util-types';
+import { ArrayTag, BigIntTag, BooleanTag, CustomTag, DateTag, DefaultTag, FileTag, FloatTag, IntTag, LiteralTag, NumberTag, ObjectTag, OptionalTag, SetTag, StringTag, SymbolTag, Tag, TagToType, TupleTag, TypeTag, UnionTag, UnknownTag, VoidTag } from './tag';
+interface TypeCache {
+    [Tag.string]: StringTag;
+    [Tag.number]: NumberTag;
+    [Tag.boolean]: BooleanTag;
+    [Tag.bigint]: BigIntTag;
+    [Tag.symbol]: SymbolTag;
+    [Tag.void]: VoidTag;
+    [Tag.file]: FileTag;
+    [Tag.date]: DateTag;
+    [Tag.int]: IntTag;
+    [Tag.float]: FloatTag;
+    [Tag.unknown]: UnknownTag;
+}
+/**
+ * Gets a type from the primitive type cache, creating it if it doesn't exist
+ * @param tag Primitive tag to acquire a type for
+ * @returns Proper typetag
+ */
+export declare function getType<K extends keyof TypeCache>(tag: K): TypeCache[K];
+export declare function String(): StringTag;
+export declare function Number(): NumberTag;
+export declare function Boolean(): BooleanTag;
+export declare function BigInt(): BigIntTag;
+export declare function Symbol(): SymbolTag;
+export declare function Int(): IntTag;
+export declare function Float(): FloatTag;
+export declare function Void(): VoidTag;
+export declare function File(): FileTag;
+export declare function Date(): DateTag;
+export declare function Unknown(): UnknownTag;
+export declare function Literal<const V extends Literable>(value: V): LiteralTag<V>;
+export declare function Array<V extends TypeTag>(element: V): ArrayTag<V>;
+export declare function Default<V extends TypeTag>(of: V, value: TagToType<V>): DefaultTag<V>;
+export declare function Set<V extends TypeTag>(element: V): SetTag<V>;
+export declare function Union<const V extends TypeTag[]>(types: V): UnionTag<V>;
+export declare function Optional<V extends TypeTag>(type: V): OptionalTag<V>;
+export declare function Object<R extends Record<string, TypeTag>>(props: R): ObjectTag<R>;
+export declare function Tuple<const V extends TypeTag[]>(types: V): TupleTag<V>;
+export declare function Custom<V>(opts: Omit<CustomTag<V>, "tag">): CustomTag<V>;
+export {};

package/dist/typing/utils.d.ts

@@ -0,0 +1,30 @@
+import { TagToType, TypeTag } from './tag';
+import { ParseResult } from '../field';
+export declare function typeToString(type: TypeTag): string;
+/**
+ * Serialize's a type into JSON
+ * @param type Type
+ * @param value Value to serialize
+ */
+export declare function serializeType<T extends TypeTag>(type: T, value: TagToType<T>): Promise<unknown>;
+/**
+ * Convert a value from it's JSON serialized version to it's Javascript representation
+ * @param type Type to parse the value as
+ * @param value JSON value to deserialize
+ * @returns Type denoted by the type parameter
+ */
+export declare function deserializeType<T extends TypeTag, R = TagToType<T>>(type: T, value: unknown): Promise<R>;
+/**
+ * Checks if the given types are exactly equal
+ * @param t1 First type to check
+ * @param t2 Second type to check
+ */
+export declare function isExactType(t1: TypeTag, t2: TypeTag): boolean;
+/**
+ * Checks to see if `test` is a valid subtype of `base`
+ * @param base Base type tag
+ * @param test Testing type tag
+ */
+export declare function isSubtype(base: TypeTag, test: TypeTag): boolean;
+export declare function isType<T extends TypeTag>(type: T, value: unknown): value is TagToType<T>;
+export declare function parseType<T extends TypeTag>(type: T, value: unknown): ParseResult<TagToType<T>>;

package/dist/util-types.d.ts

@@ -24,6 +24,10 @@ export type RemoveNeverValues<T extends object> = {
  * A type representing a dictionary from string to some type
  */
 export type Dict<T = unknown> = Record<string, T>;
+export type PartialRecord<K extends symbol | number | string, V> = {
+    [Q in K]?: V;
+};
+export type MaybeGenerator<T> = T | (() => T);
 type UndefinedKeys<T extends Dict> = {
     [K in Keyof<T>]: undefined extends T[K] ? K : never;
 }[Keyof<T>];
@@ -43,4 +47,10 @@ export type SinglularKey<T extends Record<string, any>> = {
     };
 }[keyof T];
 export type Ctor<T> = new (...args: any[]) => T;
+/**
+ * If you go over this limit, refactor you application buddy
+ */
+export type RecursionLimit = 10;
+export type PrevDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+export type Dec<D extends number> = PrevDepth[D] extends number ? PrevDepth[D] : never;
 export {};

package/dist/utils.d.ts

@@ -16,3 +16,8 @@ export declare function identity<T>(value: T): T;
  * Performs a union over `set1` and `set2`, modifying `set1` to be union of the two sets
  */
 export declare function unionSets<T>(set: Set<T>, other: Set<T>): Set<T>;
+/**
+ * Attempts to coerce a string into a number, if the number is NaN, returns the string instead
+ * @param str String to coerce
+ */
+export declare function tryNumberCoerce(str: string): string | number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@idb-orm/core",
-    "version": "1.0.11",
+    "version": "1.0.13",
     "description": "",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",

package/dist/dump/class.d.ts

@@ -1,22 +0,0 @@
-import { Arrayable, Dict } from '../util-types';
-declare abstract class Dump<T> {
-    protected readonly name: string;
-    protected readonly content: T;
-    protected readonly extension: string;
-    constructor(name: string, content: T, extension: string);
-    abstract getValue(): T;
-    abstract toFile(filename?: string, options?: FilePropertyBag): File;
-    download(filename?: string, options?: FilePropertyBag): void;
-}
-type JsonValue = Arrayable<Dict>;
-export declare class JsonDump extends Dump<JsonValue> {
-    constructor(name: string, content: JsonValue);
-    getValue(): JsonValue;
-    toFile(filename?: string, options?: FilePropertyBag): File;
-}
-export declare class CsvDump extends Dump<string> {
-    constructor(name: string, content: string);
-    getValue(): string;
-    toFile(filename?: string, options?: FilePropertyBag): File;
-}
-export {};

package/dist/dump/json.d.ts

@@ -1,9 +0,0 @@
-import { WhereObject } from '../client/types/find.js';
-import { Dict } from '../util-types';
-import { DbClient } from '../client';
-import { ValidValue } from '../field';
-import { CollectionObject } from '../model';
-import { Transaction } from '../transaction.js';
-import { JsonDump } from './class.js';
-export declare function dumpStoreToJson<Current extends Names, Names extends string, Models extends CollectionObject<Names>>(db: DbClient<string, Names, CollectionObject<Names>>, store: Current, where?: WhereObject<Models[Current] extends Dict<ValidValue> ? Models[Current] : never>, tx?: Transaction<"readonly", Names>): Promise<JsonDump>;
-export declare function dumpDatabaseToJSON<Names extends string>(db: DbClient<string, Names, any>, stores?: Names[]): Promise<JsonDump>;

package/dist/field/type-wrapper.d.ts

@@ -1,108 +0,0 @@
-import { Literable, Promisable } from '../util-types.js';
-declare const enum TypeLabel {
-    string = 0,
-    number = 1,
-    boolean = 2,
-    literal = 3,
-    date = 4,
-    symbol = 5,
-    bigint = 6,
-    array = 7,
-    set = 8,
-    union = 9,
-    optional = 10,
-    file = 11,
-    unknown = 12,
-    default = 13,
-    object = 14,
-    custom = 15
-}
-export interface StringTag {
-    tag: TypeLabel.string;
-}
-export interface NumberTag {
-    tag: TypeLabel.number;
-}
-export interface DateTag {
-    tag: TypeLabel.date;
-}
-interface BooleanTag {
-    tag: TypeLabel.boolean;
-}
-interface SymbolTag {
-    tag: TypeLabel.symbol;
-}
-interface BigIntTag {
-    tag: TypeLabel.bigint;
-}
-interface UnknownTag {
-    tag: TypeLabel.unknown;
-}
-interface FileTag {
-    tag: TypeLabel.file;
-}
-interface LiteralTag<V = unknown> {
-    tag: TypeLabel.literal;
-    value: V;
-}
-interface ArrayTag<V extends TypeTag = TypeTag> {
-    tag: TypeLabel.array;
-    of: V;
-}
-interface SetTag<V extends TypeTag = TypeTag> {
-    tag: TypeLabel.set;
-    of: V;
-}
-interface OptionalTag<V extends TypeTag = TypeTag> {
-    tag: TypeLabel.optional;
-    of: V;
-}
-interface UnionTag<V extends TypeTag[] = TypeTag[]> {
-    tag: TypeLabel.union;
-    options: V;
-}
-interface ObjectTag<P extends Record<string, TypeTag> = Record<string, TypeTag>> {
-    tag: TypeLabel.object;
-    props: P;
-}
-interface DefaultTag<V extends TypeTag = TypeTag> {
-    tag: TypeLabel.default;
-    of: V;
-}
-interface CustomTag<V = any> {
-    tag: TypeLabel.custom;
-    isType: (test: unknown) => boolean;
-    serialize?: (value: V) => Promisable<unknown>;
-    deserialize?: (value: unknown) => Promisable<V>;
-}
-export type TypeTag = LiteralTag | StringTag | NumberTag | DateTag | BooleanTag | SymbolTag | UnknownTag | FileTag | BigIntTag | SetTag | OptionalTag | UnionTag | ArrayTag | ObjectTag | DefaultTag | CustomTag;
-export declare class Type {
-    static readonly String: StringTag;
-    static readonly Number: NumberTag;
-    static readonly Boolean: BooleanTag;
-    static readonly BigInt: BigIntTag;
-    static readonly Symbol: SymbolTag;
-    static readonly File: FileTag;
-    static readonly Date: DateTag;
-    static readonly Unknown: UnknownTag;
-    static Literal<const V extends Literable>(value: V): LiteralTag<V>;
-    static Array<V extends TypeTag>(element: V): ArrayTag<V>;
-    static Set<V extends TypeTag>(element: V): SetTag<V>;
-    static Union<const V extends TypeTag[]>(types: V): UnionTag<V>;
-    static Optional<V extends TypeTag>(type: V): OptionalTag<V>;
-    static Object<R extends Record<string, TypeTag>>(props: R): ObjectTag<R>;
-    static Custom<V>({ isType, serialize, deserialize, }: {
-        isType: (test: unknown) => boolean;
-        serialize?: (value: V) => unknown;
-        deserialize?: (value: unknown) => V;
-    }): CustomTag<V>;
-    /**
-     * Serialize's a type into JSON
-     * @param type Type
-     * @param value Value to serialize
-     */
-    static serialize(type: TypeTag, value: unknown): Promise<unknown>;
-    static deserialize<T extends TypeTag>(type: T, value: unknown): Promise<unknown>;
-    static is<T extends TypeTag>(type: T, value: unknown): boolean;
-}
-export {};

package/dist/field/validators.d.ts

@@ -1,13 +0,0 @@
-import { ParseFn } from './property.js';
-/**
- *
- */
-export declare const VALIDATORS: {
-    0: ParseFn<string>;
-    1: ParseFn<number>;
-    6: ParseFn<bigint>;
-    2: ParseFn<boolean>;
-    5: ParseFn<symbol>;
-    12: ParseFn<any>;
-    4: ParseFn<Date>;
-};