schematox 0.0.5 → 0.1.0

package/README.md

@@ -75,7 +75,7 @@ export const userSchema = {
       },
       minLength: 1,
     },
-    bio: 'string?',
+    bio: { type: 'string', optional: true },
   },
 } as const satisfies Schema
 ```
@@ -179,10 +179,7 @@ import type { Schema } from 'schematox'
 
 // string
 
-const staticShortStringRequired = 'string' satisfies Schema
-const staticShortStringOptional = 'string?' satisfies Schema
-
-const staticDetailedString = {
+const staticString = {
   type: 'string',
   optional: true,
   default: 'x',
@@ -202,10 +199,7 @@ const programmaticString = string()
 
 // number
 
-const staticShortNumberRequired = 'number' satisfies Schema
-const staticShortNumberOptional = 'number?' satisfies Schema
-
-const staticDetailedNumber = {
+const staticNumber = {
   type: 'number',
   optional: true,
   default: 1,
@@ -225,10 +219,7 @@ const programmaticNumber = number()
 
 // boolean
 
-const staticShortBooleanRequired = 'boolean' satisfies Schema
-const staticShortBooleanOptional = 'boolean?' satisfies Schema
-
-const staticDetailedBoolean = {
+const staticBoolean = {
   type: 'boolean',
   optional: true,
   default: false,
@@ -321,7 +312,7 @@ const schemaX = x(
 const result = schemaX.parse({ x: { y: [{ z: 0 }] } })
 ```
 
-The `result.error` will be:
+The `result.error` shape is:
 
 ```json
 [
@@ -334,14 +325,14 @@ The `result.error` will be:
 ]
 ```
 
-If the `error` is present it's always an array which has at least one entry. Each entry has the following properties:
+It's always an array with at least one entry. Each entry includes:
 
-- `code` – could be `INVALID_TYPE` if schema subject or schema default value is not satisfies schema type requirement. Another code `INVALID_RANGE` which is about `min/max` and `minLength/maxLength` schema requirements
-- `schema` – the particular chunk of the `schema` where invalid subject value is found
-- `subject` – the particular chunk of the validated subject where invalid value is found
-- `path` – the path to error subject chunk from the root of the evaluated subject. Strings is keys and numbers are the array indexes
+- `code`: Specifies either `INVALID_TYPE` (when schema subject or default value don't meet schema type specifications), or `INVALID_RANGE` (when `min/max` or `minLength/maxLength` schema requirements aren't met).
+- `schema`: The specific section of `schema` where the invalid value is found.
+- `subject`: The specific part of the validated subject where the invalid value exists.
+- `path`: Traces the route from the root to the error subject, with strings as keys and numbers as array indexes.
 
-## Parse/validate differences
+## Parse and validate differences
 
 The parser returns `data` as new object/primitive without references to the parsed subject. Parser manages the `null` value as `undefined` and subsequently replaces it with `undefined`. It also swaps `optional` values with the `default` value from schema. One can infer schema parsed subject type by using `XParsed<typeof schema>` generic.
 
@@ -352,14 +343,14 @@ So the difference between `XParsed` and `XValidated` is just about handling `def
 Examples:
 
 ```typescript
-const optionalStrX = x('string?')
+const optionalStrX = x({ type: 'string', optional: true } as const)
 
 /* Parser doesn't check subject type */
 
 expect(optionalStrX.parse(0).error).toStrictEqual([
   {
     code: 'INVALID_TYPE',
-    schema: 'string?',
+    schema: { type: 'string', optional: true },
     subject: 0,
     path: [],
   },
@@ -371,7 +362,7 @@ expect(optionalStrX.parse(0).error).toStrictEqual([
 expect(optionalStrX.validate(0).error).toStrictEqual([
   {
     code: 'INVALID_TYPE',
-    schema: 'string?',
+    schema: { type: 'string', optional: true },
     subject: 0,
     path: [],
   },
@@ -388,7 +379,7 @@ expect(optionalStrX.parse(null).error).toBe(undefined)
 expect(optionalStrX.validate(null).error).toStrictEqual([
   {
     code: 'INVALID_TYPE',
-    schema: 'string?',
+    schema: { type: 'string', optional: true },
     subject: null,
     path: [],
   },

package/dist/base-schema-parser.js

@@ -4,69 +4,6 @@ exports.parseBaseSchemaSubject = void 0;
 var fp_1 = require("./utils/fp");
 var error_1 = require("./error");
 function parseBaseSchemaSubject(schema, subject) {
-    if (typeof schema === 'string') {
-        switch (schema) {
-            case 'string?':
-            case 'string': {
-                if (typeof subject !== 'string') {
-                    if (subject === null || subject === undefined) {
-                        if (schema === 'string?') {
-                            return (0, fp_1.data)(undefined);
-                        }
-                    }
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                return (0, fp_1.data)(subject);
-            }
-            case 'number?':
-            case 'number': {
-                if (typeof subject !== 'number') {
-                    if (subject === null || subject === undefined) {
-                        if (schema === 'number?') {
-                            return (0, fp_1.data)(undefined);
-                        }
-                    }
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                if (Number.isFinite(subject) === false) {
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                return (0, fp_1.data)(subject);
-            }
-            case 'boolean?':
-            case 'boolean': {
-                if (typeof subject !== 'boolean') {
-                    if (subject === null || subject === undefined) {
-                        if (schema === 'boolean?') {
-                            return (0, fp_1.data)(undefined);
-                        }
-                    }
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                return (0, fp_1.data)(subject);
-            }
-        }
-    }
     var updatedSubject = typeof schema.default !== undefined &&
         schema.optional &&
         (subject === null || subject === undefined)

package/dist/base-schema-validator.js

@@ -4,63 +4,6 @@ exports.validateBaseSchemaSubject = void 0;
 var fp_1 = require("./utils/fp");
 var error_1 = require("./error");
 function validateBaseSchemaSubject(schema, subject) {
-    if (typeof schema === 'string') {
-        switch (schema) {
-            case 'string?':
-            case 'string': {
-                if (typeof subject !== 'string') {
-                    if (subject === undefined && schema === 'string?') {
-                        return (0, fp_1.data)(undefined);
-                    }
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                return (0, fp_1.data)(subject);
-            }
-            case 'number?':
-            case 'number': {
-                if (typeof subject !== 'number') {
-                    if (subject === undefined && schema === 'number?') {
-                        return (0, fp_1.data)(undefined);
-                    }
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                if (Number.isFinite(subject) === false) {
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                return (0, fp_1.data)(subject);
-            }
-            case 'boolean?':
-            case 'boolean': {
-                if (typeof subject !== 'boolean') {
-                    if (subject === undefined && schema === 'boolean?') {
-                        return (0, fp_1.data)(undefined);
-                    }
-                    return (0, fp_1.error)({
-                        code: error_1.ERROR_CODE.invalidType,
-                        path: this || [],
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                return (0, fp_1.data)(subject);
-            }
-        }
-    }
     switch (schema.type) {
         case 'string': {
             if (typeof subject !== 'string') {

package/dist/general-schema-parser.js

@@ -30,8 +30,7 @@ var fp_1 = require("./utils/fp");
 var error_1 = require("./error");
 var base_schema_parser_1 = require("./base-schema-parser");
 function parse(schema, subject) {
-    if (typeof schema === 'string' ||
-        schema.type === 'string' ||
+    if (schema.type === 'string' ||
         schema.type === 'number' ||
         schema.type === 'boolean' ||
         schema.type === 'stringUnion' ||

package/dist/general-schema-validator.js

@@ -30,8 +30,7 @@ var fp_1 = require("./utils/fp");
 var error_1 = require("./error");
 var base_schema_validator_1 = require("./base-schema-validator");
 function validate(schema, subject) {
-    if (typeof schema === 'string' ||
-        schema.type === 'string' ||
+    if (schema.type === 'string' ||
         schema.type === 'number' ||
         schema.type === 'boolean' ||
         schema.type === 'stringUnion' ||

package/dist/index.js

@@ -8,8 +8,8 @@
  * but only with a MINOR version update.
  **/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.data = exports.error = exports.isData = exports.isError = exports.x = exports.validate = exports.parse = exports.object = exports.array = exports.numberUnion = exports.stringUnion = exports.boolean = exports.number = exports.string = void 0;
-/* Programmatically base schema definition */
+exports.x = exports.validate = exports.parse = exports.data = exports.error = exports.isData = exports.isError = exports.object = exports.array = exports.numberUnion = exports.stringUnion = exports.boolean = exports.number = exports.string = void 0;
+/* Programmatic base schema definition */
 var string_1 = require("./programmatic-schema/string");
 Object.defineProperty(exports, "string", { enumerable: true, get: function () { return string_1.string; } });
 var number_1 = require("./programmatic-schema/number");
@@ -20,20 +20,19 @@ var string_union_1 = require("./programmatic-schema/string-union");
 Object.defineProperty(exports, "stringUnion", { enumerable: true, get: function () { return string_union_1.stringUnion; } });
 var number_union_1 = require("./programmatic-schema/number-union");
 Object.defineProperty(exports, "numberUnion", { enumerable: true, get: function () { return number_union_1.numberUnion; } });
-/* Programmatically compound schema definition */
+/* Programmatic compound schema definition */
 var array_1 = require("./programmatic-schema/array");
 Object.defineProperty(exports, "array", { enumerable: true, get: function () { return array_1.array; } });
 var object_1 = require("./programmatic-schema/object");
 Object.defineProperty(exports, "object", { enumerable: true, get: function () { return object_1.object; } });
-/* Parser/validator/x-closure */
+var fp_1 = require("./utils/fp");
+Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return fp_1.isError; } });
+Object.defineProperty(exports, "isData", { enumerable: true, get: function () { return fp_1.isData; } });
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return fp_1.error; } });
+Object.defineProperty(exports, "data", { enumerable: true, get: function () { return fp_1.data; } });
 var general_schema_parser_1 = require("./general-schema-parser");
 Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return general_schema_parser_1.parse; } });
 var general_schema_validator_1 = require("./general-schema-validator");
 Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return general_schema_validator_1.validate; } });
 var x_closure_1 = require("./x-closure");
 Object.defineProperty(exports, "x", { enumerable: true, get: function () { return x_closure_1.x; } });
-var fp_1 = require("./utils/fp");
-Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return fp_1.isError; } });
-Object.defineProperty(exports, "isData", { enumerable: true, get: function () { return fp_1.isData; } });
-Object.defineProperty(exports, "error", { enumerable: true, get: function () { return fp_1.error; } });
-Object.defineProperty(exports, "data", { enumerable: true, get: function () { return fp_1.data; } });

package/dist/index.ts

@@ -13,7 +13,7 @@ import type {
   Con_Schema_SubjT_V,
 } from './types/compound-schema-types'
 
-/* Programmatically base schema definition */
+/* Programmatic base schema definition */
 
 export { string } from './programmatic-schema/string'
 export { number } from './programmatic-schema/number'
@@ -21,17 +21,11 @@ export { boolean } from './programmatic-schema/boolean'
 export { stringUnion } from './programmatic-schema/string-union'
 export { numberUnion } from './programmatic-schema/number-union'
 
-/* Programmatically compound schema definition */
+/* Programmatic compound schema definition */
 
 export { array } from './programmatic-schema/array'
 export { object } from './programmatic-schema/object'
 
-/* Parser/validator/x-closure */
-
-export { parse } from './general-schema-parser'
-export { validate } from './general-schema-validator'
-export { x } from './x-closure'
-
 /* Typings */
 
 export type { BaseSchema, Schema } from './types/compound-schema-types'
@@ -42,6 +36,10 @@ export type { InvalidSubject } from './error'
 export type { EitherError } from './utils/fp'
 export { isError, isData, error, data } from './utils/fp'
 
+export { parse } from './general-schema-parser'
+export { validate } from './general-schema-validator'
+export { x } from './x-closure'
+
 /* XParsed infers set optional default schema value as always present */
 export type XParsed<T extends { __schema: Schema } | Schema> = T extends {
   __schema: Schema

package/dist/programmatic-schema/boolean.d.ts

@@ -23,32 +23,32 @@ type BooleanRequired<T extends BD_Boolean> = Omit<{
     }>;
 } & BooleanShared<T>, keyof T>;
 export declare function boolean(): {
-    optional: () => ExtWith_Option<{
+    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
         readonly type: "boolean";
     }, {
-        optional: true;
+        brand: readonly [U, V];
     }, Readonly<{
         readonly type: "boolean";
     } & {
-        optional: true;
+        brand: readonly [U, V];
     }>>;
-    description: (description: string) => ExtWith_Option<{
+    optional: () => ExtWith_Option<{
         readonly type: "boolean";
     }, {
-        description: string;
+        optional: true;
     }, Readonly<{
         readonly type: "boolean";
     } & {
-        description: string;
+        optional: true;
     }>>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
+    description: (description: string) => ExtWith_Option<{
         readonly type: "boolean";
     }, {
-        brand: readonly [U, V];
+        description: string;
     }, Readonly<{
         readonly type: "boolean";
     } & {
-        brand: readonly [U, V];
+        description: string;
     }>>;
     __schema: {
         readonly type: "boolean";

package/dist/programmatic-schema/number-union.d.ts

@@ -25,38 +25,38 @@ type NumberUnionRequired<T extends BD_NumberUnion> = Omit<{
     }>;
 } & NumberUnionShared<T>, keyof T>;
 export declare function numberUnion<T extends number>(...of: Readonly<[T, ...T[]]>): {
-    optional: () => ExtWith_Option<{
+    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
         readonly type: "numberUnion";
         readonly of: readonly [T, ...T[]];
     }, {
-        optional: true;
+        brand: readonly [U, V];
     }, Readonly<{
         readonly type: "numberUnion";
         readonly of: readonly [T, ...T[]];
     } & {
-        optional: true;
+        brand: readonly [U, V];
     }>>;
-    description: (description: string) => ExtWith_Option<{
+    optional: () => ExtWith_Option<{
         readonly type: "numberUnion";
         readonly of: readonly [T, ...T[]];
     }, {
-        description: string;
+        optional: true;
     }, Readonly<{
         readonly type: "numberUnion";
         readonly of: readonly [T, ...T[]];
     } & {
-        description: string;
+        optional: true;
     }>>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
+    description: (description: string) => ExtWith_Option<{
         readonly type: "numberUnion";
         readonly of: readonly [T, ...T[]];
     }, {
-        brand: readonly [U, V];
+        description: string;
     }, Readonly<{
         readonly type: "numberUnion";
         readonly of: readonly [T, ...T[]];
     } & {
-        brand: readonly [U, V];
+        description: string;
     }>>;
     __schema: {
         readonly type: "numberUnion";

package/dist/programmatic-schema/number.d.ts

@@ -29,50 +29,50 @@ type NumberRequired<T extends BD_Number> = Omit<{
     }>;
 } & NumberShared<T>, keyof T>;
 export declare function number(): {
-    optional: () => ExtWith_Option<{
+    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
         readonly type: "number";
     }, {
-        optional: true;
+        brand: readonly [U, V];
     }, Readonly<{
         readonly type: "number";
     } & {
-        optional: true;
+        brand: readonly [U, V];
     }>>;
-    description: (description: string) => ExtWith_Option<{
+    min: (min: number) => ExtWith_Option<{
         readonly type: "number";
     }, {
-        description: string;
+        min: number;
     }, Readonly<{
         readonly type: "number";
     } & {
-        description: string;
+        min: number;
     }>>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
+    max: (max: number) => ExtWith_Option<{
         readonly type: "number";
     }, {
-        brand: readonly [U, V];
+        max: number;
     }, Readonly<{
         readonly type: "number";
     } & {
-        brand: readonly [U, V];
+        max: number;
     }>>;
-    min: (min: number) => ExtWith_Option<{
+    optional: () => ExtWith_Option<{
         readonly type: "number";
     }, {
-        min: number;
+        optional: true;
     }, Readonly<{
         readonly type: "number";
     } & {
-        min: number;
+        optional: true;
     }>>;
-    max: (max: number) => ExtWith_Option<{
+    description: (description: string) => ExtWith_Option<{
         readonly type: "number";
     }, {
-        max: number;
+        description: string;
     }, Readonly<{
         readonly type: "number";
     } & {
-        max: number;
+        description: string;
     }>>;
     __schema: {
         readonly type: "number";

package/dist/programmatic-schema/string-union.d.ts

@@ -25,38 +25,38 @@ type StringUnionRequired<T extends BD_StringUnion> = Omit<{
     }>;
 } & StringUnionShared<T>, keyof T>;
 export declare function stringUnion<T extends string>(...of: Readonly<[T, ...T[]]>): {
-    optional: () => ExtWith_Option<{
+    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
         readonly type: "stringUnion";
         readonly of: readonly [T, ...T[]];
     }, {
-        optional: true;
+        brand: readonly [U, V];
     }, Readonly<{
         readonly type: "stringUnion";
         readonly of: readonly [T, ...T[]];
     } & {
-        optional: true;
+        brand: readonly [U, V];
     }>>;
-    description: (description: string) => ExtWith_Option<{
+    optional: () => ExtWith_Option<{
         readonly type: "stringUnion";
         readonly of: readonly [T, ...T[]];
     }, {
-        description: string;
+        optional: true;
     }, Readonly<{
         readonly type: "stringUnion";
         readonly of: readonly [T, ...T[]];
     } & {
-        description: string;
+        optional: true;
     }>>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
+    description: (description: string) => ExtWith_Option<{
         readonly type: "stringUnion";
         readonly of: readonly [T, ...T[]];
     }, {
-        brand: readonly [U, V];
+        description: string;
     }, Readonly<{
         readonly type: "stringUnion";
         readonly of: readonly [T, ...T[]];
     } & {
-        brand: readonly [U, V];
+        description: string;
     }>>;
     __schema: {
         readonly type: "stringUnion";

package/dist/programmatic-schema/string.d.ts

@@ -29,50 +29,50 @@ type StringRequired<T extends BD_String> = Omit<{
     }>;
 } & StringShared<T>, keyof T>;
 export declare function string(): {
-    optional: () => ExtWith_Option<{
+    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
         readonly type: "string";
     }, {
-        optional: true;
+        brand: readonly [U, V];
     }, Readonly<{
         readonly type: "string";
     } & {
-        optional: true;
+        brand: readonly [U, V];
     }>>;
-    description: (description: string) => ExtWith_Option<{
+    minLength: (minLength: number) => ExtWith_Option<{
         readonly type: "string";
     }, {
-        description: string;
+        minLength: number;
     }, Readonly<{
         readonly type: "string";
     } & {
-        description: string;
+        minLength: number;
     }>>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
+    maxLength: (maxLength: number) => ExtWith_Option<{
         readonly type: "string";
     }, {
-        brand: readonly [U, V];
+        maxLength: number;
     }, Readonly<{
         readonly type: "string";
     } & {
-        brand: readonly [U, V];
+        maxLength: number;
     }>>;
-    minLength: (minLength: number) => ExtWith_Option<{
+    optional: () => ExtWith_Option<{
         readonly type: "string";
     }, {
-        minLength: number;
+        optional: true;
     }, Readonly<{
         readonly type: "string";
     } & {
-        minLength: number;
+        optional: true;
     }>>;
-    maxLength: (maxLength: number) => ExtWith_Option<{
+    description: (description: string) => ExtWith_Option<{
         readonly type: "string";
     }, {
-        maxLength: number;
+        description: string;
     }, Readonly<{
         readonly type: "string";
     } & {
-        maxLength: number;
+        description: string;
     }>>;
     __schema: {
         readonly type: "string";

package/dist/types/compound-schema-types.ts

@@ -1,11 +1,10 @@
-import type { BS_Schema, Con_BS_Schema_SubjT } from './base-short-schema-types'
 import type {
   BD_Schema,
   Con_BD_Schema_SubjT_P,
   Con_BD_Schema_SubjT_V,
 } from './base-detailed-schema-types'
 
-export type BaseSchema = BS_Schema | BD_Schema
+export type BaseSchema = BD_Schema
 export type CompoundSchema = ObjectSchema | ArraySchema
 export type Schema = BaseSchema | CompoundSchema
 
@@ -46,17 +45,13 @@ export type ObjectSchema<T extends Schema = NestedSchema> =
 
 /* Construct BaseSchema subject type */
 
-export type Con_BaseSchema_SubjT_P<T extends BaseSchema> = T extends BS_Schema
-  ? Con_BS_Schema_SubjT<T>
-  : T extends BD_Schema
-    ? Con_BD_Schema_SubjT_P<T>
-    : 'NEVER:Con_BaseSchema_SubjT_P'
-
-export type Con_BaseSchema_SubjT_V<T extends BaseSchema> = T extends BS_Schema
-  ? Con_BS_Schema_SubjT<T>
-  : T extends BD_Schema
-    ? Con_BD_Schema_SubjT_V<T>
-    : never
+// TODO: get rid of this intermediate type when the following issue is ready:
+//       "Remove support of default value on the schema level"
+//       https://github.com/incerta/schematox/issues/14
+export type Con_BaseSchema_SubjT_P<T extends BaseSchema> =
+  Con_BD_Schema_SubjT_P<T>
+export type Con_BaseSchema_SubjT_V<T extends BaseSchema> =
+  Con_BD_Schema_SubjT_V<T>
 
 /* Compound schema utility types */
 
@@ -104,7 +99,7 @@ export type Con_ObjectSchema_SubjT_P<T extends ObjectSchema> =
       of: infer U
     }
       ? {
-          [k in keyof U]: U[k] extends BaseSchema
+          -readonly [k in keyof U]: U[k] extends BaseSchema
             ? Con_BaseSchema_SubjT_P<U[k]>
             : U[k] extends ObjectSchema
               ? Con_ObjectSchema_SubjT_P<U[k]>
@@ -122,7 +117,7 @@ export type Con_ObjectSchema_SubjT_V<T extends ObjectSchema> =
       of: infer U
     }
       ? {
-          [k in keyof U]: U[k] extends BaseSchema
+          -readonly [k in keyof U]: U[k] extends BaseSchema
             ? Con_BaseSchema_SubjT_V<U[k]>
             : U[k] extends ObjectSchema
               ? Con_ObjectSchema_SubjT_V<U[k]>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schematox",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "description": "Define JSON compatible schema statically/programmatically and parse/validate its subject with typesafety",
   "author": "Konstantin Mazur",
   "license": "MIT",

package/dist/programmatic-schema/buffer.d.ts

@@ -1,72 +0,0 @@
-import type { BD_Buffer } from '../types/base-detailed-schema-types';
-type ExtWith_Option<T extends BD_Buffer, U, V extends BD_Buffer = Readonly<T & U>> = {
-    __schema: V;
-} & BufferOptions<V>;
-type BufferOptions<T extends BD_Buffer> = Omit<{
-    optional: () => ExtWith_Option<T, {
-        optional: true;
-    }>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<T, {
-        brand: Readonly<[U, V]>;
-    }>;
-    minLength: (minLength: number) => ExtWith_Option<T, {
-        minLength: number;
-    }>;
-    maxLength: (maxLength: number) => ExtWith_Option<T, {
-        maxLength: number;
-    }>;
-    description: (description: string) => ExtWith_Option<T, {
-        description: string;
-    }>;
-}, keyof T>;
-export declare function buffer(): {
-    optional: () => ExtWith_Option<{
-        readonly type: "buffer";
-    }, {
-        optional: true;
-    }, Readonly<{
-        readonly type: "buffer";
-    } & {
-        optional: true;
-    }>>;
-    description: (description: string) => ExtWith_Option<{
-        readonly type: "buffer";
-    }, {
-        description: string;
-    }, Readonly<{
-        readonly type: "buffer";
-    } & {
-        description: string;
-    }>>;
-    brand: <U extends string, V extends string>(key: U, value: V) => ExtWith_Option<{
-        readonly type: "buffer";
-    }, {
-        brand: readonly [U, V];
-    }, Readonly<{
-        readonly type: "buffer";
-    } & {
-        brand: readonly [U, V];
-    }>>;
-    minLength: (minLength: number) => ExtWith_Option<{
-        readonly type: "buffer";
-    }, {
-        minLength: number;
-    }, Readonly<{
-        readonly type: "buffer";
-    } & {
-        minLength: number;
-    }>>;
-    maxLength: (maxLength: number) => ExtWith_Option<{
-        readonly type: "buffer";
-    }, {
-        maxLength: number;
-    }, Readonly<{
-        readonly type: "buffer";
-    } & {
-        maxLength: number;
-    }>>;
-    __schema: {
-        readonly type: "buffer";
-    };
-};
-export {};

package/dist/programmatic-schema/buffer.js

@@ -1,61 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buffer = void 0;
-var error_1 = require("../error");
-function bufferOptions(schema) {
-    var schemaKeys = Object.keys(schema);
-    var except = new Set(schemaKeys);
-    return {
-        brand: function (key, value) {
-            if (except.has('brand')) {
-                throw Error(error_1.PROGRAMMATICALLY_DEFINED_ERROR_MSG.brandDefined);
-            }
-            var updatedSchema = __assign(__assign({}, schema), { brand: [key, value] });
-            return __assign({ __schema: updatedSchema }, bufferOptions(updatedSchema));
-        },
-        optional: function () {
-            if (except.has('optional')) {
-                throw Error(error_1.PROGRAMMATICALLY_DEFINED_ERROR_MSG.optionalDefined);
-            }
-            var updatedSchema = __assign(__assign({}, schema), { optional: true });
-            return __assign({ __schema: updatedSchema }, bufferOptions(updatedSchema));
-        },
-        minLength: function (minLength) {
-            if (except.has('minLength')) {
-                throw Error(error_1.PROGRAMMATICALLY_DEFINED_ERROR_MSG.minLengthDefined);
-            }
-            var updatedSchema = __assign(__assign({}, schema), { minLength: minLength });
-            return __assign({ __schema: updatedSchema }, bufferOptions(updatedSchema));
-        },
-        maxLength: function (maxLength) {
-            if (except.has('maxLength')) {
-                throw Error(error_1.PROGRAMMATICALLY_DEFINED_ERROR_MSG.maxLengthDefined);
-            }
-            var updatedSchema = __assign(__assign({}, schema), { maxLength: maxLength });
-            return __assign({ __schema: updatedSchema }, bufferOptions(updatedSchema));
-        },
-        description: function (description) {
-            if (except.has('description')) {
-                throw Error(error_1.PROGRAMMATICALLY_DEFINED_ERROR_MSG.descriptionDefined);
-            }
-            var updatedSchema = __assign(__assign({}, schema), { description: description });
-            return __assign({ __schema: updatedSchema }, bufferOptions(updatedSchema));
-        },
-    };
-}
-function buffer() {
-    var schema = { type: 'buffer' };
-    return __assign({ __schema: schema }, bufferOptions(schema));
-}
-exports.buffer = buffer;

package/dist/types/base-short-schema-types.ts

@@ -1,38 +0,0 @@
-export type BS_String_Req = 'string'
-export type BS_String_Opt = 'string?'
-
-export type BS_Number_Req = 'number'
-export type BS_Number_Opt = 'number?'
-
-export type BS_Boolean_Req = 'boolean'
-export type BS_Boolean_Opt = 'boolean?'
-
-export type BS_Schema_Req = BS_String_Req | BS_Number_Req | BS_Boolean_Req
-
-export type BS_Schema_Opt = BS_String_Opt | BS_Number_Opt | BS_Boolean_Opt
-
-export type BS_Schema = BS_Schema_Req | BS_Schema_Opt
-
-export type Con_BS_Schema_Req_SubjT<T extends BS_Schema_Req> =
-  T extends BS_String_Req
-    ? string
-    : T extends BS_Number_Req
-      ? number
-      : T extends BS_Boolean_Req
-        ? boolean
-        : never
-
-export type Con_BS_Schema_Opt_SubjT<T extends BS_Schema_Opt> =
-  T extends BS_String_Opt
-    ? string | undefined
-    : T extends BS_Number_Opt
-      ? number | undefined
-      : T extends BS_Boolean_Opt
-        ? boolean | undefined
-        : never
-
-export type Con_BS_Schema_SubjT<T extends BS_Schema> = T extends BS_Schema_Req
-  ? Con_BS_Schema_Req_SubjT<T>
-  : T extends BS_Schema_Opt
-    ? Con_BS_Schema_Opt_SubjT<T>
-    : never