@onetyped/core - npm Package Compare versions

Comparing version 0.1.0 to 0.1.1-canary.980a702llc8

dist/index.d.ts

@@ -1,9 +0,257 @@
-export * from './complex';
-export * from './composed';
-export * from './definitions';
-export * from './primitive';
-export * from './utils';
-export * from './print-node';
-export { defineNode } from './types';
-export type { AnyBaseNode, AnyNode, BaseNode, CustomTypeNode, Infer, } from './types';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Simplifies a type definition to its most basic representation.
+ * @see https://github.com/ianstormtaylor/superstruct/blob/41d7fdd09a0c0f0291b03357e487420d4ece6b56/src/utils.ts#L323-L325
+ */
+type Simplify<T> = T extends any[] | Date ? T : // eslint-disable-next-line @typescript-eslint/ban-types
+{
+    [K in keyof T]: T[K];
+} & {};
+type Primitive = string | number | bigint | boolean;
+
+interface StringNode extends BaseNode<'string'> {
+    readonly _type: string;
+}
+declare const string: () => StringNode;
+interface NumberNode extends BaseNode<'number'> {
+    readonly _type: number;
+}
+declare const number: () => NumberNode;
+interface BooleanNode extends BaseNode<'boolean'> {
+    readonly _type: boolean;
+}
+declare const boolean: () => BooleanNode;
+interface NullNode extends BaseNode<'null'> {
+    readonly _type: null;
+}
+declare const nullType: () => NullNode;
+interface UndefinedNode extends BaseNode<'undefined'> {
+    readonly _type: undefined;
+}
+declare const undefinedType: () => UndefinedNode;
+interface VoidNode extends BaseNode<'void'> {
+    readonly _type: void;
+}
+declare const voidType: () => VoidNode;
+interface LiteralNode<Type extends Primitive> extends BaseNode<'literal'> {
+    readonly _type: Type;
+    type: Type;
+}
+type AnyLiteralNode = LiteralNode<Primitive>;
+declare const literal: <Literal extends Primitive>(literal: Literal) => LiteralNode<Literal>;
+interface UnknownNode extends BaseNode<'unknown'> {
+    readonly _type: unknown;
+}
+declare const unknown: () => UnknownNode;
+interface AnyTypeNode extends BaseNode<'any'> {
+    readonly _type: any;
+}
+declare const any: () => AnyTypeNode;
+interface NeverNode extends BaseNode<'never'> {
+    readonly _type: never;
+}
+declare const never: () => NeverNode;
+interface RegexpNode extends BaseNode<'regexp'> {
+    readonly _type: RegExp;
+}
+declare const regexp: () => RegexpNode;
+interface BigIntNode extends BaseNode<'bigint'> {
+    readonly _type: bigint;
+}
+declare const bigint: () => BigIntNode;
+interface DateNode extends BaseNode<'date'> {
+    readonly _type: Date;
+}
+declare const date: () => DateNode;
+interface FileNode extends BaseNode<'file'> {
+    readonly _type: File;
+}
+declare const file: () => FileNode;
+interface BlobNode extends BaseNode<'blob'> {
+    readonly _type: Blob;
+}
+declare const blob: () => BlobNode;
+interface SymbolNode extends BaseNode<'symbol'> {
+    readonly _type: symbol;
+    readonly name: string;
+}
+declare const symbol: (name: string) => SymbolNode;
+
+declare const defaults: {};
+type Defaults = typeof defaults;
+interface BaseNode<TypeName extends string> {
+    readonly _type: any;
+    typeName: TypeName;
+}
+type AnyBaseNode = BaseNode<any>;
+type AnyBasicNode = Omit<AnyBaseNode, keyof Defaults | '_type'> & {
+    [Key in keyof Defaults]?: AnyBaseNode[Key];
+};
+declare const defineNode: <T extends AnyBasicNode>(node: T) => T & {
+    _type: any;
+};
+type Infer<TNode extends AnyBaseNode> = TNode['_type'];
+type AnyNode = StringNode | NumberNode | BooleanNode | NullNode | UndefinedNode | AnyLiteralNode | UnknownNode | VoidNode | AnyTypeNode | NeverNode | RegexpNode | BigIntNode | DateNode | FileNode | BlobNode | SymbolNode | AnyCustomNode | AnyFormDataNode | AnyObjectNode | AnyArrayNode | AnySetNode | AnyRecordNode | AnyMapNode | AnyFunctionNode | AnyUnionNode | AnyTupleNode | AnyIntersectionNode | AnyNamedNode | AnyIteratorNode | DefinitionReferenceNode;
+type InferNodeArray<TNodes extends AnyBaseNode[], InferredTypes extends unknown[] = []> = TNodes extends [
+    infer Head extends AnyBaseNode,
+    ...infer Rest extends AnyBaseNode[]
+] ? InferNodeArray<Rest, [...InferredTypes, Infer<Head>]> : InferredTypes;
+interface CustomTypeNode<TType> extends BaseNode<any> {
+    _type: TType;
+}
+
+type AnyObjectShape = {
+    [key: string]: AnyBaseNode;
+};
+interface ObjectNode<Shape extends AnyObjectShape> extends BaseNode<'object'> {
+    readonly _type: Simplify<{
+        [Property in keyof Shape as undefined extends Infer<Shape[Property]> ? never : Property]: Infer<Shape[Property]>;
+    } & {
+        [Property in keyof Shape as undefined extends Infer<Shape[Property]> ? Property : never]?: Infer<Shape[Property]>;
+    }>;
+    shape: Shape;
+}
+type AnyObjectNode = ObjectNode<{
+    [key: string]: any;
+}>;
+declare const object: <TShape extends AnyObjectShape>(shape: TShape) => ObjectNode<TShape>;
+interface ArrayNode<Type extends AnyBaseNode> extends BaseNode<'array'> {
+    readonly _type: Infer<Type>[];
+    type: Type;
+}
+type AnyArrayNode = ArrayNode<any>;
+declare const array: <TNode extends AnyBaseNode>(type: TNode) => ArrayNode<TNode>;
+interface IteratorNode<Type extends AnyBaseNode> extends BaseNode<'iterator'> {
+    readonly _type: Infer<Type>[];
+    type: Type;
+}
+type AnyIteratorNode = IteratorNode<any>;
+declare const iterator: <TNode extends AnyBaseNode>(type: TNode) => IteratorNode<TNode>;
+interface SetNode<Type extends AnyBaseNode> extends BaseNode<'set'> {
+    readonly _type: Set<Infer<Type>>;
+    type: Type;
+}
+type AnySetNode = SetNode<any>;
+declare const set: <TNode extends AnyBaseNode>(type: TNode) => SetNode<TNode>;
+interface AnyRecordKeyNode extends AnyBaseNode {
+    readonly _type: string | number;
+}
+interface RecordNode<KeyNode extends AnyBaseNode, ValueNode extends AnyBaseNode> extends BaseNode<'record'> {
+    readonly _type: Record<Infer<KeyNode>, Infer<ValueNode>>;
+    key: KeyNode;
+    value: ValueNode;
+}
+type AnyRecordNode = RecordNode<any, any>;
+declare const record: <KeyNode extends AnyRecordKeyNode, ValueNode extends AnyBaseNode>(key: KeyNode, value: ValueNode) => RecordNode<KeyNode, ValueNode>;
+interface MapNode<KeyNode extends AnyBaseNode, ValueNode extends AnyBaseNode> extends BaseNode<'map'> {
+    readonly _type: Map<Infer<KeyNode>, Infer<ValueNode>>;
+    key: KeyNode;
+    value: ValueNode;
+}
+type AnyMapNode = MapNode<any, any>;
+declare const map: <KeyNode extends AnyBaseNode, ValueNode extends AnyBaseNode>(key: KeyNode, value: ValueNode) => MapNode<KeyNode, ValueNode>;
+interface FunctionNode<TArguments extends AnyBaseNode[], TReturn extends AnyBaseNode | undefined> extends BaseNode<'function'> {
+    readonly _type: (...arguments_: TArguments extends AnyBaseNode[] ? InferNodeArray<TArguments> : []) => TReturn extends AnyBaseNode ? Infer<TReturn> : void;
+    arguments: TArguments;
+    return: TReturn;
+}
+type AnyFunctionNode = FunctionNode<any[], any>;
+declare const func: <TReturn extends AnyBaseNode, TArgument extends AnyBaseNode, TArguments extends AnyBaseNode[] = []>(options?: {
+    arguments?: [TArgument, ...TArguments] | undefined;
+    return?: TReturn | undefined;
+}) => FunctionNode<[TArgument, ...TArguments], TReturn>;
+interface UnionNode<Types extends AnyBaseNode[]> extends BaseNode<'union'> {
+    readonly _type: {
+        [K in keyof Types]: Infer<Types[K]>;
+    }[number];
+    types: Types;
+}
+type AnyUnionNode = UnionNode<any>;
+declare const union: <TNode extends AnyBaseNode, TNodes extends AnyBaseNode[]>(nodes: [TNode, ...TNodes]) => UnionNode<[TNode, ...TNodes]>;
+interface TupleNode<Types extends AnyBaseNode[]> extends BaseNode<'tuple'> {
+    readonly _type: InferNodeArray<Types>;
+    types: Types;
+}
+type AnyTupleNode = TupleNode<any>;
+declare const tuple: <TNode extends AnyBaseNode, TNodes extends AnyBaseNode[]>(nodes: [TNode, ...TNodes]) => TupleNode<[TNode, ...TNodes]>;
+type InferIntersection<TNodes extends AnyBaseNode[], InferredType = never> = TNodes extends [
+    infer Head extends AnyBaseNode,
+    ...infer Rest extends AnyBaseNode[]
+] ? InferIntersection<Rest, InferredType & Infer<Head>> : InferredType;
+interface IntersectionNode<Types extends AnyBaseNode[]> extends BaseNode<'intersection'> {
+    readonly _type: InferIntersection<Types>;
+    types: Types;
+}
+type AnyIntersectionNode = IntersectionNode<any>;
+declare const intersection: <TNode extends AnyBaseNode, TNodes extends AnyBaseNode[]>(nodes: [TNode, ...TNodes]) => IntersectionNode<[TNode, ...TNodes]>;
+interface DefinitionReferenceNode extends BaseNode<'definitionReference'> {
+    readonly _type: unknown;
+    identifier: string;
+    text: string;
+}
+declare const definitionReference: (identifier: string, text: string) => DefinitionReferenceNode;
+interface NamedNode<TNode extends AnyBaseNode> extends BaseNode<'named'> {
+    node: TNode;
+    name: string;
+}
+type AnyNamedNode = NamedNode<any>;
+declare const named: <TNode extends AnyBaseNode>(node: TNode, name: string) => NamedNode<TNode>;
+type AnyFormDataShape = {
+    [name: string]: AnyBaseNode;
+};
+interface FormDataNode<Shape extends AnyFormDataShape> extends BaseNode<'formData'> {
+    readonly _type: Simplify<{
+        [Property in keyof Shape as undefined extends Infer<Shape[Property]> ? never : Property]: Infer<Shape[Property]>;
+    } & {
+        [Property in keyof Shape as undefined extends Infer<Shape[Property]> ? Property : never]?: Infer<Shape[Property]>;
+    }>;
+    shape?: Shape;
+}
+type AnyFormDataNode = FormDataNode<{
+    [key: string]: any;
+}>;
+declare const formData: <TShape extends AnyFormDataShape>(shape?: TShape | undefined) => FormDataNode<TShape>;
+interface CustomNode<TType, TArguments extends AnyBaseNode[]> extends BaseNode<'custom'> {
+    readonly _type: {
+        type: TType;
+        arguments: InferNodeArray<TArguments>;
+    };
+    readonly name: string;
+    readonly arguments?: TArguments;
+}
+type AnyCustomNode = CustomNode<any, any[]>;
+declare const custom: <TType, TArguments extends AnyBaseNode[]>(name: string, arguments_?: TArguments | undefined) => CustomNode<TType, TArguments>;
+
+declare const nullable: <TNode extends AnyBaseNode>(type: TNode) => UnionNode<[TNode, NullNode]>;
+declare const optional: <TNode extends AnyBaseNode>(type: TNode) => UnionNode<[TNode, UndefinedNode]>;
+
+type DefinitionMap = Map<string, AnyNode>;
+
+declare const mapMultipleInnerNode: <TMapperResult>(node: AnyBaseNode & {
+    types: AnyNode[];
+}, mapper: (node: AnyNode) => TMapperResult) => TMapperResult[];
+declare const mapObjectNode: <TMapperResult>(node: AnyObjectNode, mapper: (node: AnyNode) => TMapperResult) => (readonly [string, TMapperResult])[];
+declare const serializePrimitive: (value: Primitive) => string;
+declare const isNodeOptional: (node: AnyNode) => any;
+declare const unionIfMultiple: <TNode extends AnyBaseNode>(nodes: [TNode, ...TNode[]]) => TNode | UnionNode<[TNode, ...TNode[]]>;
+declare class UnsupportedError extends Error {
+    readonly integration: string;
+    readonly feature: string;
+    constructor(integration: string, feature: string);
+}
+/**
+ * Creates a function that stabilizes e.g. `__@toStringTag@123` to `__@toStringTag@0`
+ */
+declare function createUnstableStringGuard(): (key: string) => string;
+
+interface PrintNodeOptions {
+    indent?: number;
+    depth?: number;
+}
+/**
+ * This method does not print an "optimized" version of the node in terms of
+ * parentheses, indentation, etc. To get a pretty-printed version, use
+ * `printNode` from `@onetyped/typescript` instead to get help from the compiler.
+ */
+declare function printNode(node: AnyNode, options?: PrintNodeOptions): string;
+
+export { AnyArrayNode, AnyBaseNode, AnyCustomNode, AnyFormDataNode, AnyFormDataShape, AnyFunctionNode, AnyIntersectionNode, AnyIteratorNode, AnyLiteralNode, AnyMapNode, AnyNamedNode, AnyNode, AnyObjectNode, AnyObjectShape, AnyRecordKeyNode, AnyRecordNode, AnySetNode, AnyTupleNode, AnyTypeNode, AnyUnionNode, ArrayNode, BaseNode, BigIntNode, BlobNode, BooleanNode, CustomNode, CustomTypeNode, DateNode, DefinitionMap, DefinitionReferenceNode, FileNode, FormDataNode, FunctionNode, Infer, IntersectionNode, IteratorNode, LiteralNode, MapNode, NamedNode, NeverNode, NullNode, NumberNode, ObjectNode, RecordNode, RegexpNode, SetNode, StringNode, SymbolNode, TupleNode, UndefinedNode, UnionNode, UnknownNode, UnsupportedError, VoidNode, any, array, bigint, blob, boolean, createUnstableStringGuard, custom, date, defineNode, definitionReference, file, formData, func, intersection, isNodeOptional, iterator, literal, map, mapMultipleInnerNode, mapObjectNode, named, never, nullType, nullable, number, object, optional, printNode, record, regexp, serializePrimitive, set, string, symbol, tuple, undefinedType, union, unionIfMultiple, unknown, voidType };

package.json

 {
   "name": "@onetyped/core",
-  "version": "0.1.0",
+  "version": "0.1.1-canary.980a702llc8",
   "type": "module",
@@ -5,0 +5,0 @@ "description": "one schema to rule them all",

No alert changes

Improved metrics

Total package byte prevSize

59113

increased by25.05%

Lines of code

1425

increased by20.87%

No dependency changes