@tstdl/base 0.87.13 → 0.88.0-alpha1

package/schema/types/types.js

@@ -1,203 +1,173 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-__export(types_exports, {
-  isDeferredValueType: () => isDeferredValueType,
-  isObjectSchema: () => isObjectSchema,
-  isSchema: () => isSchema,
-  isTransformErrorResult: () => isTransformErrorResult,
-  isTypeSchema: () => isTypeSchema,
-  isValueSchema: () => isValueSchema,
-  objectSchema: () => objectSchema,
-  objectSchemaProperties: () => objectSchemaProperties,
-  optimizeObjectSchema: () => optimizeObjectSchema,
-  optimizeObjectSchemaProperties: () => optimizeObjectSchemaProperties,
-  optimizeSchema: () => optimizeSchema,
-  optimizeValueSchema: () => optimizeValueSchema,
-  primitiveConstructorSet: () => primitiveConstructorSet,
-  primitiveConstructors: () => primitiveConstructors,
-  resolveValueType: () => resolveValueType,
-  resolveValueTypes: () => resolveValueTypes,
-  schemaTestableToSchema: () => schemaTestableToSchema,
-  schemaTestablesToSchemas: () => schemaTestablesToSchemas,
-  transformErrorResult: () => transformErrorResult,
-  transformErrorResultSymbol: () => transformErrorResultSymbol,
-  typeSchema: () => typeSchema,
-  valueSchema: () => valueSchema
-});
-module.exports = __toCommonJS(types_exports);
-var import_array = require("../../utils/array/array.js");
-var import_object = require("../../utils/object/object.js");
-var import_type_guards = require("../../utils/type-guards.js");
-const optimized = Symbol("schema optimized");
-const primitiveConstructors = [String, Number, Boolean, Symbol, BigInt, Function, "undefined", "null"];
-const primitiveConstructorSet = new Set(primitiveConstructors);
-const transformErrorResultSymbol = Symbol("Transform error");
-function transformErrorResult(error) {
-  return { [transformErrorResultSymbol]: error };
-}
-function isTransformErrorResult(value) {
-  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, transformErrorResultSymbol);
-}
-function objectSchemaProperties(properties) {
-  return optimizeObjectSchemaProperties(properties);
-}
-function objectSchema(schema) {
-  return optimizeObjectSchema(schema);
-}
-function valueSchema(schema, options) {
-  (0, import_type_guards.assert)(!(0, import_type_guards.isArray)(schema) || schema.length > 0, "No schema provided.");
-  return optimizeValueSchema({ schema, ...options });
-}
-function typeSchema(type) {
-  return { type };
-}
-function isSchema(value) {
-  return isObjectSchema(value) || isValueSchema(value) || isTypeSchema(value);
-}
-function isObjectSchema(schema) {
-  return (0, import_type_guards.isObject)(schema?.properties);
-}
-function isValueSchema(schema) {
-  return (0, import_type_guards.isObject)(schema) && (0, import_type_guards.isDefined)(schema?.schema);
-}
-function isTypeSchema(schema) {
-  if (!(0, import_type_guards.isObject)(schema)) {
-    return false;
-  }
-  const type = schema.type;
-  return (0, import_type_guards.isObject)(schema) && ((0, import_type_guards.isFunction)(type) || (0, import_type_guards.isObject)(type) && (0, import_type_guards.isFunction)(type.deferred) || type == "undefined" || type == "null" || type == "any");
-}
-function isDeferredValueType(value) {
-  return (0, import_type_guards.isObject)(value) && (0, import_type_guards.isFunction)(value.deferred);
-}
-function resolveValueTypes(valueTypes) {
-  if ((0, import_type_guards.isArray)(valueTypes)) {
-    return valueTypes.map(resolveValueType);
-  }
-  return resolveValueType(valueTypes);
-}
-function resolveValueType(valueType) {
-  return isDeferredValueType(valueType) ? resolveValueType(valueType.deferred()) : valueType;
-}
-function schemaTestablesToSchemas(schemaTestables) {
-  if ((0, import_type_guards.isArray)(schemaTestables)) {
-    if (schemaTestables.length == 1) {
-      return schemaTestableToSchema(schemaTestables[0]);
-    }
-    if (schemaTestables.length == 0) {
-      throw new Error("No schema provided.");
+/* eslint-disable @typescript-eslint/ban-types */
+import { distinct } from '../../utils/array/array.js';
+import { filterObject, hasOwnProperty, mapObjectValues, objectEntries, objectKeys } from '../../utils/object/object.js';
+import { assert, isArray, isDefined, isFunction, isObject, isString, isUndefined } from '../../utils/type-guards.js';
+const optimized = Symbol('schema optimized');
+export const primitiveConstructors = [String, Number, Boolean, Symbol, BigInt, Function, 'undefined', 'null'];
+export const primitiveConstructorSet = new Set(primitiveConstructors);
+export const transformErrorResultSymbol = Symbol('Transform error');
+export function transformErrorResult(error) {
+    return { [transformErrorResultSymbol]: error };
+}
+export function isTransformErrorResult(value) {
+    return isObject(value) && hasOwnProperty(value, transformErrorResultSymbol);
+}
+export function objectSchemaProperties(properties) {
+    return optimizeObjectSchemaProperties(properties);
+}
+export function objectSchema(schema) {
+    return optimizeObjectSchema(schema);
+}
+export function valueSchema(schema, options) {
+    assert(!isArray(schema) || (schema.length > 0), 'No schema provided.');
+    return optimizeValueSchema({ schema, ...options });
+}
+export function typeSchema(type) {
+    return { type };
+}
+export function isSchema(value) {
+    return isObjectSchema(value) || isValueSchema(value) || isTypeSchema(value);
+}
+export function isObjectSchema(schema) {
+    return isObject(schema?.properties);
+}
+export function isValueSchema(schema) {
+    return isObject(schema) && isDefined(schema?.schema);
+}
+export function isTypeSchema(schema) {
+    if (!isObject(schema)) {
+        return false;
     }
-    return schemaTestables.map(schemaTestableToSchema);
-  }
-  return schemaTestableToSchema(schemaTestables);
-}
-function schemaTestableToSchema(valueTypeOrSchema) {
-  if (isSchema(valueTypeOrSchema)) {
-    return valueTypeOrSchema;
-  }
-  return typeSchema(valueTypeOrSchema);
-}
-function optimizeObjectSchema(schema) {
-  if (schema[optimized] == true) {
-    return schema;
-  }
-  return (0, import_object.filterObject)({
-    [optimized]: true,
-    ...schema,
-    properties: optimizeObjectSchemaProperties(schema.properties),
-    unknownProperties: (0, import_type_guards.isUndefined)(schema.unknownProperties) || (0, import_type_guards.isArray)(schema.unknownProperties) && schema.unknownProperties.length == 0 ? void 0 : optimizeSchema(schema.unknownProperties),
-    unknownPropertiesKey: (0, import_type_guards.isUndefined)(schema.unknownPropertiesKey) || (0, import_type_guards.isArray)(schema.unknownPropertiesKey) && schema.unknownPropertiesKey.length == 0 ? void 0 : optimizeSchema(schema.unknownPropertiesKey)
-  }, import_type_guards.isDefined);
-}
-function optimizeObjectSchemaProperties(properties) {
-  return (0, import_object.mapObjectValues)(properties, optimizeSchema);
-}
-function optimizeValueSchema(schema) {
-  const optimizedSchema = optimizeSchema(schema);
-  return isValueSchema(optimizedSchema) ? optimizedSchema : { [optimized]: true, schema: optimizedSchema };
-}
-function optimizeSchema(schema) {
-  if ((0, import_type_guards.isArray)(schema)) {
-    if (schema[optimized] == true) {
-      return schema;
+    const type = schema.type;
+    return isObject(schema)
+        && (isFunction(type)
+            || (isObject(type) && isFunction(type.deferred))
+            || (type == 'undefined')
+            || (type == 'null')
+            || (type == 'any'));
+}
+export function isDeferredValueType(value) {
+    return isObject(value) && isFunction(value.deferred);
+}
+export function resolveValueTypes(valueTypes) {
+    if (isArray(valueTypes)) {
+        return valueTypes.map(resolveValueType);
     }
-    if (schema.length == 1) {
-      return optimizeSchema(schema[0]);
+    return resolveValueType(valueTypes);
+}
+export function resolveValueType(valueType) {
+    return isDeferredValueType(valueType)
+        ? resolveValueType(valueType.deferred())
+        : valueType;
+}
+export function schemaTestablesToSchemas(schemaTestables) {
+    if (isArray(schemaTestables)) {
+        if (schemaTestables.length == 1) {
+            return schemaTestableToSchema(schemaTestables[0]);
+        }
+        if (schemaTestables.length == 0) {
+            throw new Error('No schema provided.');
+        }
+        return schemaTestables.map(schemaTestableToSchema);
     }
-    if (schema.length == 0) {
-      throw new Error("No schema provided.");
+    return schemaTestableToSchema(schemaTestables);
+}
+export function schemaTestableToSchema(valueTypeOrSchema) {
+    if (isSchema(valueTypeOrSchema)) {
+        return valueTypeOrSchema;
     }
-    const optimizedSchemas = (0, import_array.distinct)((0, import_array.distinct)(schema).flatMap(optimizeSchema));
-    optimizedSchemas[optimized] = true;
-    return optimizedSchemas;
-  }
-  if ((0, import_type_guards.isFunction)(schema) || (0, import_type_guards.isString)(schema) || isDeferredValueType(schema)) {
-    return schema;
-  }
-  if (isTypeSchema(schema)) {
-    return schema.type;
-  }
-  if (isValueSchema(schema)) {
+    return typeSchema(valueTypeOrSchema);
+}
+export function optimizeObjectSchema(schema) {
     if (schema[optimized] == true) {
-      return schema;
+        return schema;
+    }
+    return filterObject({
+        [optimized]: true,
+        ...schema,
+        properties: optimizeObjectSchemaProperties(schema.properties),
+        unknownProperties: (isUndefined(schema.unknownProperties) || (isArray(schema.unknownProperties) && (schema.unknownProperties.length == 0))) ? undefined : optimizeSchema(schema.unknownProperties),
+        unknownPropertiesKey: (isUndefined(schema.unknownPropertiesKey) || (isArray(schema.unknownPropertiesKey) && (schema.unknownPropertiesKey.length == 0))) ? undefined : optimizeSchema(schema.unknownPropertiesKey)
+    }, isDefined);
+}
+export function optimizeObjectSchemaProperties(properties) {
+    return mapObjectValues(properties, optimizeSchema);
+}
+export function optimizeValueSchema(schema) {
+    const optimizedSchema = optimizeSchema(schema);
+    return isValueSchema(optimizedSchema) ? optimizedSchema : { [optimized]: true, schema: optimizedSchema };
+}
+export function optimizeSchema(schema) {
+    if (isArray(schema)) {
+        if (schema[optimized] == true) {
+            return schema;
+        }
+        if (schema.length == 1) {
+            return optimizeSchema(schema[0]);
+        }
+        if (schema.length == 0) {
+            throw new Error('No schema provided.');
+        }
+        const optimizedSchemas = distinct(distinct(schema).flatMap(optimizeSchema));
+        optimizedSchemas[optimized] = true;
+        return optimizedSchemas;
     }
-    const entries = (0, import_object.objectEntries)(schema).filter(([, value]) => (0, import_type_guards.isDefined)(value));
-    if (entries.length == 1) {
-      return optimizeSchema(schema.schema);
+    if (isFunction(schema) || isString(schema) || isDeferredValueType(schema)) {
+        return schema;
     }
-    if (isValueSchema(schema.schema)) {
-      const combinedProperties = /* @__PURE__ */ new Set([...(0, import_object.objectKeys)(schema), ...(0, import_object.objectKeys)(schema.schema)]);
-      if (isValueSchema(schema.schema) && !combinedProperties.has("array") && !combinedProperties.has("coerce") && !combinedProperties.has("coercers") && !combinedProperties.has("transformers") && !combinedProperties.has("arrayConstraints") && !combinedProperties.has("valueConstraints")) {
-        return {
-          [optimized]: true,
-          schema: optimizeSchema(schema.schema.schema),
-          ...(0, import_object.filterObject)({
-            optional: (schema.optional ?? false) || (schema.schema.optional ?? false) ? true : void 0,
-            nullable: (schema.nullable ?? false) || (schema.schema.nullable ?? false) ? true : void 0
-          }, import_type_guards.isDefined)
-        };
-      }
+    if (isTypeSchema(schema)) {
+        return schema.type;
     }
-    const { schema: innerSchema, optional, nullable, coercers, transformers, arrayConstraints, valueConstraints, ...rest } = schema;
-    return (0, import_object.filterObject)({
-      [optimized]: true,
-      schema: optimizeSchema(innerSchema),
-      optional: optional ?? false ? true : void 0,
-      nullable: nullable ?? false ? true : void 0,
-      coercers: optimizeOneOrMany(coercers),
-      transformers: optimizeOneOrMany(transformers),
-      arrayConstraints: optimizeOneOrMany(arrayConstraints),
-      valueConstraints: optimizeOneOrMany(valueConstraints),
-      ...rest
-    }, import_type_guards.isDefined);
-  }
-  return optimizeObjectSchema(schema);
+    if (isValueSchema(schema)) {
+        if (schema[optimized] == true) {
+            return schema;
+        }
+        const entries = objectEntries(schema).filter(([, value]) => isDefined(value));
+        if (entries.length == 1) {
+            return optimizeSchema(schema.schema);
+        }
+        if (isValueSchema(schema.schema)) {
+            const combinedProperties = new Set([...objectKeys(schema), ...objectKeys(schema.schema)]);
+            if (isValueSchema(schema.schema)
+                && !combinedProperties.has('array')
+                && !combinedProperties.has('coerce')
+                && !combinedProperties.has('coercers')
+                && !combinedProperties.has('transformers')
+                && !combinedProperties.has('arrayConstraints')
+                && !combinedProperties.has('valueConstraints')) {
+                return {
+                    [optimized]: true,
+                    schema: optimizeSchema(schema.schema.schema),
+                    ...filterObject({
+                        optional: ((schema.optional ?? false) || (schema.schema.optional ?? false)) ? true : undefined,
+                        nullable: ((schema.nullable ?? false) || (schema.schema.nullable ?? false)) ? true : undefined
+                    }, isDefined)
+                };
+            }
+        }
+        const { schema: innerSchema, optional, nullable, coercers, transformers, arrayConstraints, valueConstraints, ...rest } = schema;
+        return filterObject({
+            [optimized]: true,
+            schema: optimizeSchema(innerSchema),
+            optional: (optional ?? false) ? true : undefined,
+            nullable: (nullable ?? false) ? true : undefined,
+            coercers: optimizeOneOrMany(coercers),
+            transformers: optimizeOneOrMany(transformers),
+            arrayConstraints: optimizeOneOrMany(arrayConstraints),
+            valueConstraints: optimizeOneOrMany(valueConstraints),
+            ...rest
+        }, isDefined);
+    }
+    return optimizeObjectSchema(schema);
 }
 function optimizeOneOrMany(values) {
-  if ((0, import_type_guards.isArray)(values)) {
-    if (values.length == 0) {
-      return void 0;
-    }
-    if (values.length == 1) {
-      return values[0];
+    if (isArray(values)) {
+        if (values.length == 0) {
+            return undefined;
+        }
+        if (values.length == 1) {
+            return values[0];
+        }
     }
-  }
-  return values;
+    return values;
 }

package/schema/utils/index.js

@@ -1,19 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-module.exports = __toCommonJS(utils_exports);
-__reExport(utils_exports, require("./schema.js"), module.exports);
-__reExport(utils_exports, require("./value-type.js"), module.exports);
+export * from './schema.js';
+export * from './value-type.js';