@tstdl/base 0.91.0-beta2 → 0.91.0-beta4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.0-beta2",
+  "version": "0.91.0-beta4",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/schema/schemas/object.d.ts

@@ -1,6 +1,8 @@
 import type { EmptyObject, Merge } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { AbstractConstructor, OneOrMany, PartialProperty, Record, SimplifyObject, Type, TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { SchemaPropertyDecorator } from '../decorators/types.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
 export type ObjectSchemaFactory<T> = {
@@ -65,11 +67,13 @@ export declare function assign<T1 extends Record, T2 extends Record, T3 extends
 export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
 export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
 export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record, T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
-export declare function partial<T extends Record>(schema: ObjectSchema<T>): ObjectSchema<Partial<T>>;
-export declare function partial<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
-export declare function pick<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
-export declare function omit<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function partial<T extends Record>(schema: ObjectSchemaOrType<T>): ObjectSchema<Partial<T>>;
+export declare function partial<T extends Record, K extends keyof T>(schema: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+export declare function pick<T extends Record, K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
+export declare function omit<T extends Record, K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
 export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
 declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | null;
+export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
+export declare function Record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
 export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
 export {};

package/schema/schemas/object.js

@@ -6,6 +6,7 @@ import { memoizeSingle } from '../../utils/function/memoize.js';
 import { filterObject, mapObjectValues, objectKeys } from '../../utils/object/object.js';
 import { assert, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 import { array } from './array.js';
@@ -79,21 +80,15 @@ export function record(key, value, options) {
     return object({}, { ...options, unknownPropertiesKey: key, unknownProperties: value });
 }
 export function assign(...schemasOrTypes) {
-    const schemas = schemasOrTypes.map((schemaOrType) => {
-        if (schemaOrType instanceof ObjectSchema) {
-            return schemaOrType;
-        }
-        const typeSchema = getSchemaFromReflection(schemaOrType);
-        assert(typeSchema instanceof ObjectSchema, 'assign() only works with object schemas.');
-        return typeSchema;
-    });
+    const schemas = schemasOrTypes.map(getObjectSchema);
     return object(schemas.reduce((result, schema) => ({ ...result, ...schema.properties }), {}), {
         mask: schemas.findLast((schema) => isNotNull(schema.mask))?.mask,
         unknownProperties: schemas.findLast((schema) => isNotNull(schema.unknownProperties))?.unknownProperties,
         unknownPropertiesKey: schemas.findLast((schema) => isNotNull(schema.unknownPropertiesKey))?.unknownPropertiesKey
     });
 }
-export function partial(schema, keyOrKeys) {
+export function partial(schemaOrType, keyOrKeys) {
+    const schema = getObjectSchema(schemaOrType);
     const keys = isUndefined(keyOrKeys) ? undefined : toArray(keyOrKeys);
     const mapper = isUndefined(keys)
         ? (propertySchema) => optional(propertySchema)
@@ -104,7 +99,8 @@ export function partial(schema, keyOrKeys) {
         unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
-export function pick(schema, keys) {
+export function pick(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
     const keyArray = toArray(keys);
     return object(filterObject(schema.properties, (_, key) => keyArray.includes(key)), {
         mask: schema.mask,
@@ -112,7 +108,8 @@ export function pick(schema, keys) {
         unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
-export function omit(schema, keys) {
+export function omit(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
     const keysArray = toArray(keys);
     return object(filterObject(schema.properties, (_, key) => !keysArray.includes(key)), {
         mask: schema.mask,
@@ -174,4 +171,16 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     }
     return properties;
 }
+export function getObjectSchema(schemaOrType) {
+    if (schemaOrType instanceof ObjectSchema) {
+        return schemaOrType;
+    }
+    if (isFunction(schemaOrType)) {
+        return getObjectSchema(getSchemaFromReflection(schemaOrType));
+    }
+    throw new Error('Could not infer ObjectSchema.');
+}
+export function Record(key, value, options) {
+    return Property(record(key, value, options), options);
+}
 export const emptyObjectSchema = explicitObject({});