@tstdl/base 0.91.46 → 0.91.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.46",
+  "version": "0.91.48",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -115,7 +115,7 @@
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.28"
+    "type-fest": "4.30"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -128,14 +128,14 @@
     "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.16",
+    "@typescript-eslint/eslint-plugin": "8.17",
     "concurrently": "9.1",
     "drizzle-kit": "0.28",
     "eslint": "8.57",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.31",
     "tsc-alias": "1.8",
-    "typedoc": "0.26",
+    "typedoc": "0.27",
     "typedoc-plugin-missing-exports": "3.1",
     "typescript": "5.6"
   },

package/schema/schemas/enumeration.d.ts

@@ -2,11 +2,11 @@ import type { Enumeration as EnumerationType, EnumerationValue } from '../../typ
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type EnumerationSchemaOptions = SimpleSchemaOptions;
-export declare class EnumerationSchema<T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
+export declare class EnumerationSchema<const T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
     #private;
     readonly name: string;
     readonly enumeration: EnumerationType;
     constructor(enumeration: T, options?: EnumerationSchemaOptions);
 }
-export declare function enumeration<T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions): EnumerationSchema<T>;
+export declare function enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions): EnumerationSchema<T>;
 export declare function Enumeration(enumeration: EnumerationType, options?: EnumerationSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/object.d.ts

@@ -18,8 +18,8 @@ export type NormalizedObjectSchemaProperties<T extends Record> = {
 export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey = PropertyKey, V = unknown> = {
     name?: string;
     mask?: boolean | null;
-    unknownProperties?: SchemaTestable<V> | null;
     unknownPropertiesKey?: SchemaTestable<K> | null;
+    unknownProperties?: SchemaTestable<V> | null;
     factory?: ObjectSchemaFactory<T> | null;
 };
 export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
@@ -47,32 +47,33 @@ export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
 export declare function object<const K extends PropertyKey, const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<Record<K, V>>;
+}): ObjectSchema<Partial<Record<K, V>>>;
 export declare function object<const K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
     unknownProperties?: undefined;
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<Record<K, unknown>>;
+}): ObjectSchema<Partial<Record<K, unknown>>>;
 export declare function object<const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey?: undefined;
-}): ObjectSchema<Record<PropertyKey, V>>;
+}): ObjectSchema<Partial<Record<PropertyKey, V>>>;
 export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, V>>>;
 export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, unknown>> & {
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, unknown>>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, unknown>>>;
 export declare function object<const TP extends ObjectSchemaProperties, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>> & {
     unknownProperties: SchemaTestable<V>;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<PropertyKey, V>>>;
 export declare function object<const TP extends ObjectSchemaProperties>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>> & {
     unknownProperties?: undefined;
     unknownPropertiesKey?: undefined;
 }): ObjectSchema<ObjectSchemaPropertiesType<TP>>;
-export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, V>>>;
 export declare function explicitObject<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
-export declare function record<const K extends PropertyKey, const V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
+export declare function record<const K extends PropertyKey, const V>(keys: K[], value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
+export declare function record<const K extends PropertyKey, const V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Partial<Record<K, V>>>;
 export declare function assign<const T1 extends Record, const T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
 export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
 export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;

package/schema/schemas/object.js

@@ -3,8 +3,8 @@ import { createDecorator, reflectionRegistry } from '../../reflection/index.js';
 import { SchemaError } from '../../schema/schema.error.js';
 import { toArray } from '../../utils/array/array.js';
 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 { filterObject, fromEntries, mapObjectValues, objectKeys } from '../../utils/object/object.js';
+import { assert, isArray, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Class, Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
@@ -78,8 +78,13 @@ export function object(properties, options) {
 export function explicitObject(properties, options) {
     return object(properties, options);
 }
-export function record(key, value, options) {
-    return object({}, { ...options, unknownPropertiesKey: key, unknownProperties: value });
+export function record(keysOrKeySchema, value, options) {
+    if (isArray(keysOrKeySchema)) {
+        const entries = keysOrKeySchema.map((key) => [key, value]);
+        const properties = fromEntries(entries);
+        return new ObjectSchema(properties, options);
+    }
+    return new ObjectSchema({}, { ...options, unknownPropertiesKey: keysOrKeySchema, unknownProperties: value });
 }
 export function assign(...schemasOrTypes) {
     const schemas = schemasOrTypes.map(getObjectSchema);

package/types.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
-import type { CamelCase, Except } from 'type-fest';
+import type { CamelCase, Except, IsEqual, LiteralUnion } from 'type-fest';
 import type { Signal } from './signals/api.js';
 export type ObjectLiteral = {};
 export type PrimitiveTypeMap = {
@@ -132,6 +132,7 @@ export type SimplifyDeep<T> = T extends BuiltIn ? T : T extends readonly any[] ?
 } : T extends Record ? {
     [K in keyof T]: SimplifyDeep<T[K]>;
 } & {} : T;
+export type SimplifiedLiteralUnion<LiteralType, BaseType extends Primitive> = If<IsEqual<LiteralType, BaseType>, LiteralType, LiteralUnion<LiteralType, string>>;
 export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection : never;
 export type UnionToTuple<T, Tuple extends any[] = []> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? UnionToTuple<Exclude<T, R>, [R, ...Tuple]> : Tuple;
 export type UndefinableObject<T extends Record> = {