@fncts/schema 0.0.13 → 0.0.15

package/_src/AST.ts

@@ -623,6 +623,11 @@ export function createTuple(
   return new Tuple(elements, rest, isReadonly, annotations);
 }
 
+/**
+ * @tsplus static fncts.schema.ASTOps unknownArray
+ */
+export const unknownArray = AST.createTuple(Vector.empty(), Just(Vector(AST.unknownKeyword)), true);
+
 /*
  * PropertySignature
  */
@@ -732,6 +737,17 @@ export function createTypeLiteral(
   return new TypeLiteral(propertySignatures, indexSignatures, annotations);
 }
 
+/**
+ * @tsplus static fncts.schema.ASTOps unknownRecord
+ */
+export const unknownRecord = AST.createTypeLiteral(
+  Vector.empty(),
+  Vector(
+    AST.createIndexSignature(AST.stringKeyword, AST.unknownKeyword, true),
+    AST.createIndexSignature(AST.symbolKeyword, AST.unknownKeyword, true),
+  ),
+);
+
 /*
  * Union
  */
@@ -814,18 +830,20 @@ export class Refinement extends AST {
   readonly _tag = ASTTag.Refinement;
   constructor(
     readonly from: AST,
-    readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>,
-    readonly isReversed: boolean,
+    readonly predicate: (input: any) => boolean,
     readonly annotations: ASTAnnotationMap = ASTAnnotationMap.empty,
   ) {
     super();
   }
 
+  decode(input: any, options?: ParseOptions): ParseResult<any> {
+    return this.predicate(input) ? ParseResult.succeed(input) : ParseResult.fail(ParseError.TypeError(this, input));
+  }
+
   clone(newProperties: Partial<this>): AST {
     return new Refinement(
       newProperties.from ?? this.from,
-      newProperties.decode ?? this.decode,
-      newProperties.isReversed ?? this.isReversed,
+      newProperties.predicate ?? this.predicate,
       newProperties.annotations ?? this.annotations,
     );
   }
@@ -836,11 +854,10 @@ export class Refinement extends AST {
  */
 export function createRefinement(
   from: AST,
-  decode: (input: any, options?: ParseOptions) => ParseResult<any>,
-  isReversed: boolean,
+  predicate: (input: any) => boolean,
   annotations?: ASTAnnotationMap,
 ): Refinement {
-  return new Refinement(from, decode, isReversed, annotations);
+  return new Refinement(from, predicate, annotations);
 }
 
 export function isRefinement(self: AST): self is Refinement {
@@ -864,7 +881,6 @@ export class Transform extends AST {
     readonly to: AST,
     readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>,
     readonly encode: (input: any, options?: ParseOptions) => ParseResult<any>,
-    readonly isReversed: boolean,
     readonly annotations: ASTAnnotationMap = ASTAnnotationMap.empty,
   ) {
     super();
@@ -876,7 +892,6 @@ export class Transform extends AST {
       newProperties.to ?? this.to,
       newProperties.decode ?? this.decode,
       newProperties.encode ?? this.encode,
-      newProperties.isReversed ?? this.isReversed,
       newProperties.annotations ?? this.annotations,
     );
   }
@@ -890,10 +905,9 @@ export function createTransform(
   to: AST,
   decode: (input: any, options?: ParseOptions) => ParseResult<any>,
   encode: (input: any, options?: ParseOptions) => ParseResult<any>,
-  isReversed: boolean,
   annotations?: ASTAnnotationMap,
 ): Transform {
-  return new Transform(from, getTo(to), decode, encode, isReversed, annotations);
+  return new Transform(from, getTo(to), decode, encode, annotations);
 }
 
 /*
@@ -1317,48 +1331,13 @@ export function getTo(ast: AST): AST {
     case ASTTag.Lazy:
       return AST.createLazy(() => getTo(ast.getAST()), ast.annotations);
     case ASTTag.Refinement:
-      return AST.createRefinement(getTo(ast.from), ast.decode, false, ast.annotations);
+      return AST.createRefinement(getTo(ast.from), ast.predicate, ast.annotations);
     case ASTTag.Transform:
       return getTo(ast.to);
   }
   return ast;
 }
 
-/**
- * @tsplus getter fncts.schema.AST reverse
- */
-export function reverse(ast: AST): AST {
-  AST.concrete(ast);
-  switch (ast._tag) {
-    case ASTTag.Declaration:
-      return AST.createDeclaration(ast.typeParameters.map(reverse), ast.type, ast.decode, ast.annotations);
-    case ASTTag.Tuple:
-      return AST.createTuple(
-        ast.elements.map((element) => AST.createElement(reverse(element.type), element.isOptional)),
-        ast.rest.map((restElement) => restElement.map(reverse)),
-        ast.isReadonly,
-        ast.annotations,
-      );
-    case ASTTag.TypeLiteral:
-      return AST.createTypeLiteral(
-        ast.propertySignatures.map((ps) =>
-          AST.createPropertySignature(ps.name, reverse(ps.type), ps.isOptional, ps.isReadonly, ps.annotations),
-        ),
-        ast.indexSignatures.map((is) => AST.createIndexSignature(is.parameter, reverse(is.type), is.isReadonly)),
-        ast.annotations,
-      );
-    case ASTTag.Union:
-      return AST.createUnion(ast.types.map(reverse), ast.annotations);
-    case ASTTag.Lazy:
-      return AST.createLazy(() => reverse(ast.getAST()), ast.annotations);
-    case ASTTag.Refinement:
-      return AST.createRefinement(ast.from, ast.decode, !ast.isReversed, ast.annotations);
-    case ASTTag.Transform:
-      return AST.createTransform(reverse(ast.from), ast.to, ast.decode, ast.encode, !ast.isReversed, ast.annotations);
-  }
-  return ast;
-}
-
 /**
  * @tsplus static fncts.schema.AST getCompiler
  */
@@ -1369,3 +1348,73 @@ export function getCompiler<A>(match: AST.Match<A>): AST.Compiler<A> {
   });
   return compile;
 }
+
+export function getLiterals(ast: AST, isDecoding: boolean): ReadonlyArray<[PropertyKey, Literal]> {
+  AST.concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.Declaration:
+      return getLiterals(ast.type, isDecoding);
+    case ASTTag.TypeLiteral: {
+      const out: Array<[PropertyKey, Literal]> = [];
+      for (let i = 0; i < ast.propertySignatures.length; i++) {
+        const propertySignature = ast.propertySignatures[i]!;
+        if (propertySignature.type.isLiteral() && !propertySignature.isOptional) {
+          out.push([propertySignature.name, propertySignature.type]);
+        }
+      }
+      return out;
+    }
+    case ASTTag.Refinement:
+      return getLiterals(ast.from, isDecoding);
+    case ASTTag.Transform:
+      return getLiterals(isDecoding ? ast.from : ast.to, isDecoding);
+  }
+  return [];
+}
+
+export function getSearchTree(
+  members: Vector<AST>,
+  isDecoding: boolean,
+): {
+  keys: {
+    readonly [key: PropertyKey]: {
+      buckets: { [literal: string]: ReadonlyArray<AST> };
+      ast: AST;
+    };
+  };
+  otherwise: ReadonlyArray<AST>;
+} {
+  const keys: {
+    [key: PropertyKey]: {
+      buckets: { [literal: string]: Array<AST> };
+      ast: AST;
+    };
+  } = {};
+  const otherwise: Array<AST> = [];
+  for (let i = 0; i < members.length; i++) {
+    const member = members[i]!;
+    const tags   = getLiterals(member, isDecoding);
+    if (tags.length > 0) {
+      for (let j = 0; j < tags.length; j++) {
+        const [key, literal] = tags[j]!;
+        const hash           = String(literal.literal);
+        keys[key]!         ||= { buckets: {}, ast: AST.neverKeyword };
+        const buckets        = keys[key]!.buckets;
+        if (Object.prototype.hasOwnProperty.call(buckets, hash)) {
+          if (j < tags.length - 1) {
+            continue;
+          }
+          buckets[hash]!.push(member);
+          keys[key]!.ast = AST.createUnion(Vector(keys[key]!.ast, literal));
+        } else {
+          buckets[hash]! = [member];
+          keys[key]!.ast = AST.createUnion(Vector(keys[key]!.ast, literal));
+          break;
+        }
+      }
+    } else {
+      otherwise.push(member);
+    }
+  }
+  return { keys, otherwise };
+}

package/_src/Guard.ts

@@ -0,0 +1,268 @@
+import { globalValue } from "@fncts/base/data/Global";
+import { isRecord } from "@fncts/base/util/predicates";
+import { getKeysForIndexSignature, memoize } from "@fncts/schema/utils";
+
+import { ASTTag, getSearchTree } from "./AST.js";
+import { parserFor } from "./Parser.js";
+
+/**
+ * @tsplus getter fncts.schema.Schema is
+ */
+export function is<A>(schema: Schema<A>) {
+  return (input: unknown): input is A => {
+    return guardFor(schema).is(input);
+  };
+}
+
+export function guardFor<A>(schema: Schema<A>): Guard<A> {
+  return goMemo(schema.ast);
+}
+
+const guardStrict = (value: unknown) => Guard((inp): inp is any => inp === value);
+
+const guardMemoMap = globalValue(Symbol.for("fncts.schema.Guard.guardMemoMap"), () => new WeakMap<AST, Guard<any>>());
+
+function goMemo(ast: AST): Guard<any> {
+  const memo = guardMemoMap.get(ast);
+  if (memo) {
+    return memo;
+  }
+  const guard = go(ast);
+  guardMemoMap.set(ast, guard);
+  return guard;
+}
+
+function go(ast: AST): Guard<any> {
+  AST.concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.Declaration: {
+      const parser = parserFor(ast, true);
+      return Guard((inp): inp is any =>
+        parser(inp).match(
+          () => false,
+          () => true,
+        ),
+      );
+    }
+    case ASTTag.Literal: {
+      return Guard((inp): inp is any => inp === ast.literal);
+    }
+    case ASTTag.UniqueSymbol: {
+      return guardStrict(ast.symbol);
+    }
+    case ASTTag.VoidKeyword:
+    case ASTTag.UndefinedKeyword: {
+      return guardStrict(undefined);
+    }
+    case ASTTag.NeverKeyword: {
+      return Guard((inp): inp is never => false);
+    }
+    case ASTTag.UnknownKeyword:
+    case ASTTag.AnyKeyword: {
+      return Guard((inp): inp is any => true);
+    }
+    case ASTTag.NumberKeyword: {
+      return Guard.number;
+    }
+    case ASTTag.BooleanKeyword: {
+      return Guard.boolean;
+    }
+    case ASTTag.StringKeyword: {
+      return Guard.string;
+    }
+    case ASTTag.BigIntKeyword: {
+      return Guard.bigint;
+    }
+    case ASTTag.SymbolKeyword: {
+      return Guard((inp): inp is symbol => typeof inp === "symbol");
+    }
+    case ASTTag.ObjectKeyword: {
+      return Guard(isObject);
+    }
+    case ASTTag.TemplateLiteral: {
+      const parser = parserFor(ast, true);
+      return Guard((inp): inp is any =>
+        parser(inp).match(
+          () => false,
+          () => true,
+        ),
+      );
+    }
+    case ASTTag.Tuple: {
+      const elements     = ast.elements.map((element) => goMemo(element.type));
+      const restElements = ast.rest.match(
+        () => Vector.empty<Guard<any>>(),
+        (rest) => rest.map(goMemo),
+      );
+
+      return Guard((input): input is any => {
+        if (!Array.isArray(input)) {
+          return false;
+        }
+
+        let i = 0;
+        for (; i < elements.length; i++) {
+          if (input.length < i + 1) {
+            if (!ast.elements[i]!.isOptional) {
+              return false;
+            }
+          } else {
+            const guard = elements[i]!;
+            if (!guard.is(input[i])) {
+              return false;
+            }
+          }
+        }
+
+        if (restElements.length > 0) {
+          const head = restElements.unsafeHead!;
+          const tail = restElements.tail;
+          for (; i < input.length - tail.length; i++) {
+            if (!head.is(input[i])) {
+              return false;
+            }
+          }
+          for (let j = 0; j < tail.length; j++) {
+            i += j;
+            if (input.length < i + 1) {
+              return false;
+            }
+            const guard = tail[j]!;
+            if (!guard.is(input[i])) {
+              return false;
+            }
+          }
+        }
+
+        return true;
+      });
+    }
+    case ASTTag.TypeLiteral: {
+      if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
+        return Guard((input): input is Exclude<typeof input, null> => input !== null);
+      }
+      const propertySignatureTypes = ast.propertySignatures.map((ps) => goMemo(ps.type));
+      const indexSignatures        = ast.indexSignatures.map((is) => [goMemo(is.parameter), goMemo(is.type)] as const);
+      return Guard((input): input is any => {
+        if (!isRecord(input)) {
+          return false;
+        }
+
+        const expectedKeys: any = {};
+
+        console.log(ast.propertySignatures);
+        for (let i = 0; i < propertySignatureTypes.length; i++) {
+          const ps           = ast.propertySignatures[i]!;
+          const guard        = propertySignatureTypes[i]!;
+          const name         = ps.name;
+          expectedKeys[name] = null;
+          if (!Object.prototype.hasOwnProperty.call(input, name)) {
+            if (!ps.isOptional) {
+              return false;
+            }
+          } else {
+            if (!guard(input[name])) {
+              return false;
+            }
+          }
+        }
+
+        if (indexSignatures.length > 0) {
+          for (let i = 0; i < indexSignatures.length; i++) {
+            const [parameter, type] = indexSignatures[i]!;
+            const keys              = getKeysForIndexSignature(input, ast.indexSignatures[i]!.parameter);
+            for (const key of keys) {
+              if (Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
+                continue;
+              }
+
+              if (!parameter(key)) {
+                return false;
+              }
+
+              if (!type(input[key])) {
+                return false;
+              }
+            }
+          }
+        }
+
+        return true;
+      });
+    }
+    case ASTTag.Union: {
+      const searchTree = getSearchTree(ast.types, true);
+      const ownKeys    = Reflect.ownKeys(searchTree.keys);
+      const len        = ownKeys.length;
+      const otherwise  = searchTree.otherwise;
+      const map        = new Map<any, Guard<any>>();
+      ast.types.forEach((ast) => {
+        map.set(ast, goMemo(ast));
+      });
+      return Guard((input): input is any => {
+        if (len > 0) {
+          if (isRecord(input)) {
+            for (let i = 0; i < len; i++) {
+              const name    = ownKeys[i]!;
+              const buckets = searchTree.keys[name]!.buckets;
+              if (Object.prototype.hasOwnProperty.call(input, name)) {
+                const literal = String(input[name]);
+                if (Object.prototype.hasOwnProperty.call(buckets, literal)) {
+                  const bucket: ReadonlyArray<AST> = buckets[literal]!;
+                  for (let i = 0; i < bucket.length; i++) {
+                    if (map.get(bucket[i])!(input)) {
+                      return true;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        for (let i = 0; i < otherwise.length; i++) {
+          if (map.get(otherwise[i])!(input)) {
+            return true;
+          }
+        }
+        return false;
+      });
+    }
+    case ASTTag.Lazy: {
+      const f   = () => goMemo(ast.getAST());
+      const get = memoize<void, Guard<any>>(f);
+      return Guard((input): input is any => get()(input));
+    }
+    case ASTTag.Enum: {
+      return Guard((input): input is any => ast.enums.some(([_, value]) => value === input));
+    }
+    case ASTTag.Refinement: {
+      const from = goMemo(ast.from);
+      return Guard((input): input is any => {
+        if (!from(input)) {
+          return false;
+        }
+        if (!ast.predicate(input)) {
+          return false;
+        }
+        return true;
+      });
+    }
+    case ASTTag.Transform: {
+      return goMemo(ast.to);
+    }
+    case ASTTag.Validation: {
+      const from = goMemo(ast.from);
+      return Guard((input): input is any => {
+        if (!from(input)) {
+          return false;
+        }
+        for (const validation of ast.validation) {
+          if (!validation.validate(input)) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+  }
+}

package/_src/ParseError.ts

@@ -1,4 +1,4 @@
-import type { TemplateLiteral, TemplateLiteralSpan, Validation } from "@fncts/schema/AST";
+import type { Refinement, TemplateLiteral, TemplateLiteralSpan, Transform, Validation } from "@fncts/schema/AST";
 
 import { showWithOptions } from "@fncts/base/data/Showable";
 import { concrete } from "@fncts/schema/AST";
@@ -12,6 +12,8 @@ export const enum ParseErrorTag {
   Missing,
   Unexpected,
   UnionMember,
+  Refinement,
+  Transformation,
 }
 
 /**
@@ -24,8 +26,9 @@ export type ParseError =
   | KeyError
   | MissingError
   | UnexpectedError
-  | UnexpectedError
-  | UnionMemberError;
+  | UnionMemberError
+  | RefinementError
+  | TransformationError;
 
 /**
  * @tsplus companion fncts.schema.ParseError.TypeError
@@ -78,7 +81,7 @@ export class KeyError {
 }
 
 /**
- * @tsplus static fncts.schema.ParseError.IndexError __call
+ * @tsplus static fncts.schema.ParseError.KeyError __call
  * @tsplus static fncts.schema.ParseErrorOps KeyError
  */
 export function keyError(keyAST: AST, key: any, errors: Vector<ParseError>): ParseError {
@@ -129,6 +132,58 @@ export function unionMemberError(errors: Vector<ParseError>): ParseError {
   return new UnionMemberError(errors);
 }
 
+/**
+ * @tsplus companion fncts.schema.ParseError.RefinementError
+ */
+export class RefinementError {
+  readonly _tag = ParseErrorTag.Refinement;
+  constructor(
+    readonly ast: Refinement,
+    readonly actual: unknown,
+    readonly kind: "From" | "Predicate",
+    readonly errors: Vector<ParseError>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.RefinementError __call
+ * @tsplus static fncts.schema.ParseErrorOps RefinementError
+ */
+export function refinementError(
+  ast: Refinement,
+  actual: unknown,
+  kind: "From" | "Predicate",
+  errors: Vector<ParseError>,
+): ParseError {
+  return new RefinementError(ast, actual, kind, errors);
+}
+
+/**
+ * @tsplus companion fncts.schema.ParseError.TransformationError
+ */
+export class TransformationError {
+  readonly _tag = ParseErrorTag.Transformation;
+  constructor(
+    readonly ast: Transform,
+    readonly actual: unknown,
+    readonly kind: "Encoded" | "Transformation" | "Type",
+    readonly errors: Vector<ParseError>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.TransformationError __call
+ * @tsplus static fncts.schema.ParseErrorOps TransformationError
+ */
+export function transformationError(
+  ast: Transform,
+  actual: unknown,
+  kind: "Encoded" | "Transformation" | "Type",
+  errors: Vector<ParseError>,
+): ParseError {
+  return new TransformationError(ast, actual, kind, errors);
+}
+
 /**
  * @tsplus static fncts.schema.ParseErrorOps format
  */
@@ -153,6 +208,31 @@ function formatTemplateLiteral(ast: TemplateLiteral): string {
   return ast.head + ast.spans.map((span) => formatTemplateLiteralSpan(span) + span.literal).join("");
 }
 
+function formatRefinementKind(error: RefinementError): string {
+  switch (error.kind) {
+    case "From": {
+      return "From side refinement failure";
+    }
+    case "Predicate": {
+      return "Predicate refinement failure";
+    }
+  }
+}
+
+function formatTransformationKind(error: TransformationError): string {
+  switch (error.kind) {
+    case "Encoded": {
+      return "Encoded side transformation failure";
+    }
+    case "Transformation": {
+      return "Transformation process failure";
+    }
+    case "Type": {
+      return "Type side transformation failure";
+    }
+  }
+}
+
 function getExpected(ast: AST): Maybe<string> {
   return ast.annotations
     .get(ASTAnnotation.Identifier)
@@ -243,5 +323,9 @@ function go(error: ParseError): RoseTree<string> {
       return RoseTree("is missing");
     case ParseErrorTag.UnionMember:
       return RoseTree("union member", error.errors.map(go));
+    case ParseErrorTag.Refinement:
+      return RoseTree(formatRefinementKind(error), error.errors.map(go));
+    case ParseErrorTag.Transformation:
+      return RoseTree(formatTransformationKind(error), error.errors.map(go));
   }
 }

package/_src/ParseFailure.ts

@@ -0,0 +1,18 @@
+export const ParseFailureTypeId = Symbol.for("fncts.schema.ParseFailure");
+export type ParseFailureTypeId = typeof ParseFailureTypeId;
+
+/**
+ * @tsplus type fncts.schema.ParseFailure
+ * @tsplus companion fncts.schema.ParseFailureOps
+ */
+export class ParseFailure {
+  readonly [ParseFailureTypeId]: ParseFailureTypeId = ParseFailureTypeId;
+  constructor(readonly errors: Vector<ParseError>) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseFailureOps __call
+ */
+export function make(errors: Vector<ParseError>): ParseFailure {
+  return new ParseFailure(errors);
+}

package/_src/ParseResult.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.schema.ParseResult
  * @tsplus companion fncts.schema.ParseResultOps
  */
-export interface ParseResult<A> extends Either<Vector<ParseError>, A> {}
+export interface ParseResult<A> extends Either<ParseFailure, A> {}
 
 /**
  * @tsplus static fncts.schema.ParseResultOps succeed
@@ -15,12 +15,12 @@ export function succeed<A>(value: A): ParseResult<A> {
  * @tsplus static fncts.schema.ParseResultOps failures
  */
 export function failures<A = never>(value: Vector<ParseError>): ParseResult<A> {
-  return Either.left(value);
+  return Either.left(ParseFailure(value));
 }
 
 /**
  * @tsplus static fncts.schema.ParseResultOps fail
  */
 export function fail<A = never>(value: ParseError): ParseResult<A> {
-  return Either.left(Vector(value));
+  return Either.left(ParseFailure(Vector(value)));
 }