@shapecraft/core 1.0.0

package/src/shape/shape.ts

@@ -0,0 +1,377 @@
+import { forceString, isPlainObject, uniqueBy } from "../common";
+import { remapObjectValues } from "../common/object";
+import { Arrayish, Binary, Prettify } from "../common/types";
+import { AnnotatedLoose, Annotation } from "./annotation";
+import {
+  _WithPhantom,
+  createBaseWithInput as bwi,
+  createBaseWithPhantom as bwp,
+  ShapeBase,
+  ShapeLoose,
+} from "./base";
+import {
+  inferNumberTag,
+  inferNumberTagFromSamples,
+} from "./number";
+import { NumberTag } from "./tags";
+import * as _validate from "./validate";
+
+export namespace shapes {
+  ///////////////////////////////////// types ///////////////////////////////////////////////
+
+  // ---------- primitives
+  export interface ShapeNumber<
+    Input extends number | null = number | null,
+    Tag extends NumberTag = NumberTag,
+  > extends ShapeBase<
+    "number",
+    Input,
+    [Input] extends [number] ? Input : number
+  > {
+    tag: Tag;
+    literal?: boolean;
+  }
+
+  export interface ShapeString<
+    Input extends string | null = string | null,
+  > extends ShapeBase<
+    "string",
+    Input,
+    [Input] extends [string] ? Input : string
+  > {
+    literal?: boolean;
+  }
+
+  export interface ShapeBoolean<
+    Input extends boolean | null = boolean | null,
+  > extends ShapeBase<
+    "boolean",
+    Input,
+    [Input] extends [boolean] ? Input : boolean
+  > {
+    literal?: boolean;
+  }
+
+  export interface ShapeUndefined extends ShapeBase<
+    "undefined",
+    null,
+    undefined
+  > {}
+  export interface ShapeDate extends ShapeBase<"date", null, Date> {}
+  export interface ShapeNil extends ShapeBase<"nil", null, null> {}
+  export interface ShapeUnknown extends ShapeBase<"unknown", null, unknown> {}
+
+  // ---------- collections
+  export interface ShapeArray<Item extends Shape = Shape> extends ShapeBase<
+    "array",
+    Item,
+    Array<InferShapeOut<Item>>
+  > {}
+
+  export interface ShapeMapping<
+    Rec extends { [key: string]: Shape } = { [key: string]: Shape },
+  > extends ShapeBase<"mapping", Rec, Record<string, Shape>> {
+    input: Rec;
+    _: {
+      output: Prettify<
+        {
+          -readonly [P in keyof Rec as [IsOptional<Rec[P]>] extends [true] ?
+            never
+          : P]: InferShapeOut<Rec[P]>;
+        } & {
+          -readonly [P in keyof Rec as [IsOptional<Rec[P]>] extends [true] ? P
+          : never]?: InferShapeOut<Rec[P]>;
+        }
+      >;
+    };
+  }
+
+  export interface ShapeRecord<
+    KV extends [ShapeKeyable, Shape] = [ShapeKeyable, Shape],
+  > extends ShapeBase<
+    "record",
+    KV,
+    Record<InferShapeOut<KV[0]>, InferShapeOut<KV[1]>>
+  > {}
+
+  export interface ShapeVector<
+    Dims extends number = number,
+    Format extends ShapeNumber = ShapeNumber,
+  > extends ShapeBase<
+    "vector",
+    { dims: Dims; format: Format },
+    Array<InferShapeOut<Format>>
+  > {}
+
+  export interface ShapeTuple<
+    Of extends readonly Shape[] = readonly Shape[],
+  > extends ShapeBase<
+    "tuple",
+    Of,
+    { -readonly [K in keyof Of]: InferShapeOut<Of[K]> }
+  > {}
+
+  export interface ShapeBinary extends ShapeBase<"binary", null, Binary> {}
+
+  export interface ShapeRange<Item extends Shape = Shape> extends ShapeBase<
+    "range",
+    Item,
+    {
+      lower: InferShapeOut<Item> | null;
+      upper: InferShapeOut<Item> | null;
+      lowerInclusive: boolean;
+      upperInclusive: boolean;
+    }
+  > {}
+
+  export interface ShapeUnion<
+    Of extends Arrayish<Shape> = Arrayish<Shape>,
+  > extends ShapeBase<"union", Of, InferShapeOut<Of[`${number}`]>> {}
+
+  export interface ShapeModule<
+    Rec extends Record<string, ShapeMapping> = Record<string, ShapeMapping>,
+  > extends ShapeBase<"module", Rec, Record<string, unknown>> {
+    input: Rec;
+    _: {
+      output: {
+        -readonly [P in keyof Rec]: InferShapeOut<Rec[P]>;
+      };
+    };
+  }
+
+  export type ShapeKeyable = ShapeString | ShapeNumber | ShapeBoolean;
+
+  export type ShapeWithLength = ShapeString | ShapeNumber | ShapeArray;
+
+  export type ShapeLiteral =
+    | MakeLiteral<ShapeString<string>>
+    | MakeLiteral<ShapeNumber<number>>
+    | MakeLiteral<ShapeBoolean<boolean>>;
+
+  export type Shape =
+    | ShapeNumber
+    | ShapeString
+    | ShapeBoolean
+    | ShapeUndefined
+    | ShapeDate
+    | ShapeNil
+    | ShapeUnknown
+    | ShapeArray
+    | ShapeMapping
+    | ShapeRecord
+    | ShapeVector
+    | ShapeTuple
+    | ShapeBinary
+    | ShapeRange
+    | ShapeUnion
+    | ShapeModule
+    | ShapeLiteral;
+
+  ///////////////////////////////////// type utilities ////////////////////////////////////////
+  export type InferShapeOut<S> =
+    [S] extends [_WithPhantom] ? S["_"]["output"] : never;
+
+  export type InputOfShape<S extends Shape> = S["input"];
+
+  export type Annotated<
+    S extends { anno: Annotation },
+    A extends Annotation,
+  > = S & {
+    anno: S["anno"] & A;
+  };
+
+  export type IsOptional<S> =
+    [S] extends [AnnotatedLoose] ?
+      [S["anno"]["optional"]] extends [true] ?
+        true
+      : false
+    : false;
+
+  export type MakeLiteral<S extends { type: string }> = S & { literal: true };
+
+  ///////////////////////////////////// constructors ////////////////////////////////////////
+
+  const withNumberTag = <
+    const S extends ShapeLoose,
+    const Tag extends NumberTag,
+  >(
+    shape: S,
+    tag: Tag,
+  ): S & { tag: Tag } => ({
+    ...shape,
+    tag: tag,
+  });
+
+  export const number = (): ShapeNumber<null, "number"> =>
+    withNumberTag(bwp("number"), "number");
+  export const int = (): ShapeNumber<null, "int"> =>
+    withNumberTag(number(), "int");
+  export const int8 = (): ShapeNumber<null, "int8"> =>
+    withNumberTag(number(), "int8");
+  export const uint8 = (): ShapeNumber<null, "uint8"> =>
+    withNumberTag(number(), "uint8");
+  export const int16 = (): ShapeNumber<null, "int16"> =>
+    withNumberTag(number(), "int16");
+  export const uint16 = (): ShapeNumber<null, "uint16"> =>
+    withNumberTag(number(), "uint16");
+  export const int32 = (): ShapeNumber<null, "int32"> =>
+    withNumberTag(number(), "int32");
+  export const uint32 = (): ShapeNumber<null, "uint32"> =>
+    withNumberTag(number(), "uint32");
+  export const int64 = (): ShapeNumber<null, "int64"> =>
+    withNumberTag(number(), "int64");
+  export const uint64 = (): ShapeNumber<null, "uint64"> =>
+    withNumberTag(number(), "uint64");
+  export const float = (): ShapeNumber<null, "float"> =>
+    withNumberTag(number(), "float");
+  export const float32 = (): ShapeNumber<null, "float32"> =>
+    withNumberTag(number(), "float32");
+  export const float64 = (): ShapeNumber<null, "float64"> =>
+    withNumberTag(number(), "float64");
+
+  export const string = (): ShapeString => bwp("string");
+  export const boolean = (): ShapeBoolean => bwp("boolean");
+  export const notDefined = (): ShapeUndefined => bwp("undefined");
+  export const date = (): ShapeDate => bwp("date");
+  export const nil = (): ShapeNil => bwp("nil");
+  export const unknown = (): ShapeUnknown => bwp("unknown");
+
+  export function literal<const Input extends boolean>(
+    value: Input,
+  ): MakeLiteral<ShapeBoolean<Input>>;
+  export function literal<const Input extends number>(
+    value: Input,
+  ): MakeLiteral<ShapeNumber<Input>>;
+  export function literal<const Input extends string>(
+    value: Input,
+  ): MakeLiteral<ShapeString<Input>>;
+  export function literal<const Input extends string | number | boolean>(
+    value: Input,
+  ): ShapeLiteral;
+  export function literal<const Input extends string | number | boolean>(
+    value: Input,
+  ): ShapeLiteral {
+    if (typeof value === "number")
+      return { ...number(), input: value, literal: true };
+    if (typeof value === "string")
+      return { ...string(), input: value, literal: true };
+    if (typeof value === "boolean")
+      return { ...boolean(), input: value, literal: true };
+    throw new Error(`type ${typeof value} cannot be a literal`);
+  }
+
+  export function array<const Item extends Shape>(
+    item: Item,
+  ): ShapeArray<Item> {
+    return bwi("array", item);
+  }
+
+  export function mapping<const Rec extends { [key: string]: Shape }>(
+    rec: Rec,
+  ): ShapeMapping<Rec> {
+    return bwi("mapping", rec);
+  }
+
+  export function record<KV extends [ShapeKeyable, Shape]>(
+    ...kv: KV
+  ): ShapeRecord<KV> {
+    return bwi("record", kv);
+  }
+
+  export function vector<const Dims extends number>(
+    dims: Dims,
+  ): ShapeVector<Dims, ShapeNumber>;
+  export function vector<
+    const Dims extends number,
+    const Format extends ShapeNumber,
+  >(dims: Dims, format: Format): ShapeVector<Dims, Format>;
+  export function vector<
+    const Dims extends number,
+    const Format extends ShapeNumber,
+  >(dims: Dims, format?: Format): ShapeVector<Dims, Format | ShapeNumber>;
+  export function vector<
+    const Dims extends number,
+    const Format extends ShapeNumber,
+  >(dims: Dims, format?: Format): ShapeVector<Dims, Format | ShapeNumber> {
+    return bwi("vector", { dims, format: format || number() });
+  }
+
+  export const binary = (): ShapeBinary => bwp("binary");
+
+  export function range<const Item extends Shape>(
+    item: Item,
+  ): ShapeRange<Item> {
+    return bwi("range", item);
+  }
+
+  export function tuple<const Of extends readonly Shape[]>(
+    ...of: Of
+  ): ShapeTuple<Of> {
+    return bwi("tuple", of);
+  }
+
+  export function union<const Of extends Array<Shape>>(of: Of): ShapeUnion<Of>;
+  export function union<const Of extends Arrayish<Shape>>(
+    ...of: Of
+  ): ShapeUnion<Of>;
+  export function union(...of: [Array<Shape>] | Arrayish<Shape>): ShapeUnion {
+    const ofs = of.flat();
+    const first = ofs[0];
+    const items: Arrayish<Shape> =
+      ofs.length === 1 && Array.isArray(first) ?
+        first
+      : (ofs as Arrayish<Shape>);
+    return bwi(
+      "union",
+      uniqueBy(items, (x) => forceString(x)),
+    );
+  }
+
+  export function module<const Rec extends Record<string, ShapeMapping>>(
+    rec: Rec,
+  ): ShapeModule<Rec> {
+    return bwi("module", rec);
+  }
+
+  export type AutoOptions = {
+    literalNumbers?: boolean | null | undefined;
+    literalStrings?: boolean | null | undefined;
+    literalBooleans?: boolean | null | undefined;
+  };
+  export function auto(input: unknown, options: AutoOptions = {}): Shape {
+    if (input === null) return nil();
+    if (typeof input === "undefined") return notDefined();
+    if (typeof input === "string")
+      return options.literalStrings ? literal(input) : string();
+    if (typeof input === "number")
+      return options.literalNumbers ?
+          withNumberTag(literal(input), inferNumberTag(input))
+        : withNumberTag(number(), inferNumberTag(input));
+    if (typeof input === "boolean")
+      return options.literalBooleans ? literal(input) : boolean();
+    if (input instanceof Date) return date();
+    if (input instanceof Uint8Array) return binary();
+    if (Array.isArray(input)) {
+      if (input.every((x) => typeof x === "number")) {
+        const tag = inferNumberTagFromSamples(input);
+        return array(withNumberTag(number(), tag));
+      }
+      if (input.length === 1) {
+        return array(auto(input[0], options));
+      }
+      return array(union(input.map((x) => auto(x, options))));
+    }
+    if (isPlainObject(input)) {
+      return mapping(remapObjectValues(input, ([_k, v]) => auto(v, options)));
+    }
+    return unknown();
+  }
+}
+
+export namespace shapes {
+  export const validate = _validate.validate;
+  export const is = _validate.is;
+  export const parse = _validate.parse;
+}
+
+export { annotate } from "./annotate";

package/src/shape/tags.ts

@@ -0,0 +1,14 @@
+export type FloatTag = "float" | "float32" | "float64";
+
+export type IntTag =
+  | "int"
+  | "int8"
+  | "uint8"
+  | "int16"
+  | "uint16"
+  | "int32"
+  | "uint32"
+  | "int64"
+  | "uint64";
+
+export type NumberTag = "number" | FloatTag | IntTag;

package/src/shape/transforms/index.ts

@@ -0,0 +1,3 @@
+export * from "./json-schema";
+export * from "./sql";
+export * from "./typescript";

package/src/shape/transforms/json-schema/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./transform";