@tstdl/base 0.91.32 → 0.91.34

package/package.json

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

package/password/password-check-result.model.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Property } from '../schema/decorators/property.js';
+import { NumberProperty } from '../schema/index.js';
 import { Array } from '../schema/schemas/array.js';
 import { Enumeration } from '../schema/schemas/enumeration.js';
 export var PasswordStrength;
@@ -33,7 +33,7 @@ __decorate([
     __metadata("design:type", Number)
 ], PasswordCheckResult.prototype, "strength", void 0);
 __decorate([
-    Property({ optional: true }),
+    NumberProperty({ optional: true }),
     __metadata("design:type", Number)
 ], PasswordCheckResult.prototype, "pwned", void 0);
 __decorate([

package/schema/decorators/property.d.ts

@@ -1,8 +1,10 @@
+import type { SetRequired } from 'type-fest';
 import type { Decorator } from '../../reflection/index.js';
 import type { TypedOmit } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
 import type { SchemaPropertyReflectionData } from './types.js';
 export type SchemaPropertyDecoratorOptions = SchemaPropertyReflectionData;
+export type SchemaPropertyDecoratorOptionsWithRequiredSchema = SetRequired<SchemaPropertyReflectionData, 'schema'>;
 export type SchemaPropertyDecoratorOptionsWithoutSchema = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
 export declare function Property(schema: SchemaTestable, options?: SchemaPropertyDecoratorOptionsWithoutSchema): Decorator<'property' | 'accessor'>;
-export declare function Property(options: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
+export declare function Property(options: SchemaPropertyDecoratorOptionsWithRequiredSchema): Decorator<'property' | 'accessor'>;

package/schema/decorators/property.js

@@ -4,7 +4,7 @@ import { isSchemaTestable } from '../testable.js';
 import { createSchemaPropertyDecorator } from './utils.js';
 export function Property(schemaOrOptions, optionsOrNothing) {
     if (isDefined(optionsOrNothing)) {
-        return createSchemaPropertyDecorator({ schema: schemaOrOptions, ...optionsOrNothing });
+        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: schemaOrOptions });
     }
     if (isSchemaTestable(schemaOrOptions)) {
         return createSchemaPropertyDecorator({ schema: schemaOrOptions });

package/schema/schemas/array.js

@@ -1,4 +1,5 @@
 import { SchemaError } from '../../schema/schema.error.js';
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isArray } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Property } from '../decorators/index.js';
@@ -12,7 +13,7 @@ export class ArraySchema extends Schema {
         super();
         this.#options = options;
         this.itemSchema = schemaTestableToSchema(itemSchema);
-        this.name = `Array[${this.itemSchema.name}]`;
+        lazyProperty(this, 'name', () => `Array[${this.itemSchema.name}]`);
     }
     _test(value, path, options) {
         if (!isArray(value)) {

package/schema/schemas/defaulted.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isNullOrUndefined } from '../../utils/type-guards.js';
 import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
@@ -10,7 +11,7 @@ export class DefaultSchema extends Schema {
         super();
         this.schema = schemaTestableToSchema(schema);
         this.defaultValue = defaultValue;
-        this.name = `Defaulted[${this.schema.name}]`;
+        lazyProperty(this, 'name', () => `Defaulted[${this.schema.name}]`);
     }
     _test(value, path, options) {
         if (isNullOrUndefined(value)) {

package/schema/schemas/enumeration.js

@@ -1,4 +1,5 @@
 import { enumValues } from '../../utils/enum.js';
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isArray, isString } from '../../utils/type-guards.js';
 import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
@@ -18,7 +19,7 @@ export class EnumerationSchema extends SimpleSchema {
         });
         this.enumeration = enumeration;
         this.#allowedValuesSet = new Set(allowedValues);
-        this.name = `Enumeration[${allowedValuesString}]`;
+        lazyProperty(this, 'name', () => `Enumeration[${allowedValuesString}]`);
     }
 }
 export function enumeration(enumeration, options) {

package/schema/schemas/instance.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
@@ -8,7 +9,7 @@ export class InstanceSchema extends Schema {
     constructor(type) {
         super();
         this.type = type;
-        this.name = `Instance[${type.name}]`;
+        lazyProperty(this, 'name', () => `Instance[${type.name}]`);
     }
     _test(value, path, options) {
         if (value instanceof this.type) {

package/schema/schemas/literal.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isPrimitive } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Property } from '../decorators/index.js';
@@ -9,7 +10,7 @@ export class LiteralSchema extends Schema {
     constructor(value) {
         super();
         this.value = value;
-        this.name = `Literal[${String(value)}]`;
+        lazyProperty(this, 'name', () => `Literal[${String(value)}]`);
     }
     _test(value, path, options) {
         if (value === this.value) {

package/schema/schemas/nullable.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isNull } from '../../utils/type-guards.js';
 import { createSchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
@@ -11,7 +12,7 @@ export class NullableSchema extends Schema {
         }
         super();
         this.schema = schemaTestableToSchema(schema);
-        this.name = `Nullable[${this.schema.name}]`;
+        lazyProperty(this, 'name', () => `Nullable[${this.schema.name}]`);
     }
     _test(value, path, options) {
         if (isNull(value)) {

package/schema/schemas/object.js

@@ -163,7 +163,7 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
         }
         let propertySchema = reflectionData?.schema ?? propertyMetadata.type;
         if (isUndefined(propertySchema)) {
-            throw new Error(`Could not infer schema for "${String(key)}" on type ${type.name}. This happens if neither explicit @Property(type) is used nor reflection metadata is available.`);
+            throw new Error(`Could not infer schema for property "${String(key)}" on type ${type.name}. This happens if neither explicit @Property(type) is used nor reflection metadata is available.`);
         }
         if (reflectionData?.array == true) {
             propertySchema = array(propertySchema);

package/schema/schemas/one-or-many.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
@@ -10,7 +11,7 @@ export class OneOrManySchema extends Schema {
         super();
         const oneSchema = schemaTestableToSchema(schema);
         this.schema = union(oneSchema, array(oneSchema));
-        this.name = `OneOrMany[${oneSchema.name}]`;
+        lazyProperty(this, 'name', () => `OneOrMany[${oneSchema.name}]`);
     }
     _test(value, path, options) {
         return this.schema._test(value, path, options);

package/schema/schemas/optional.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isUndefined } from '../../utils/type-guards.js';
 import { createSchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
@@ -11,7 +12,7 @@ export class OptionalSchema extends Schema {
         }
         super();
         this.schema = schemaTestableToSchema(schema);
-        this.name = `Optional[${this.schema.name}]`;
+        lazyProperty(this, 'name', () => `Optional[${this.schema.name}]`);
     }
     _test(value, path, options) {
         if (isUndefined(value)) {

package/schema/schemas/transform.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class TransformSchema extends Schema {
@@ -8,7 +9,7 @@ export class TransformSchema extends Schema {
         super();
         this.schema = schemaTestableToSchema(schema);
         this.transformFn = transformFn;
-        this.name = `Transform[${schema.name}]`;
+        lazyProperty(this, 'name', () => `Transform[${this.schema.name}]`);
     }
     _test(value, path, options) {
         const result = this.schema._test(value, path, options);

package/schema/schemas/union.js

@@ -1,3 +1,4 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { Schema } from '../schema.js';
@@ -14,7 +15,7 @@ export class UnionSchema extends Schema {
             }
             return schema;
         });
-        this.name = `Union[${this.schemas.map((schema) => schema.name).join(', ')}]`;
+        lazyProperty(this, 'name', () => `Union[${this.schemas.map((schema) => schema.name).join(', ')}]`);
     }
     _test(value, path, options) {
         const errors = [];