@tstdl/base 0.90.92 → 0.91.0-beta1

package/schema-old/schemas/optional.js

@@ -0,0 +1,8 @@
+import { createSchemaPropertyDecorator } from '../decorators/utils.js';
+import { valueSchema } from '../types/index.js';
+export function optional(schema, options) {
+    return valueSchema(schema, { ...options, optional: true });
+}
+export function Optional(schema) {
+    return createSchemaPropertyDecorator({ schema, optional: true });
+}

package/schema-old/schemas/readable-stream.d.ts

@@ -0,0 +1,6 @@
+import type { Decorator } from '../../reflection/index.js';
+import type { Schema } from '../schema.js';
+import type { ValueSchemaOptions } from '../types/types.js';
+export type ReadableStreamOptions = ValueSchemaOptions;
+export declare function readableStream(options?: ReadableStreamOptions): Schema<ReadableStream>;
+export declare function ReadableStreamProperty(options?: ReadableStreamOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/readable-stream.js

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
+import { valueSchema } from '../types/index.js';
+export function readableStream(options) {
+    return valueSchema(ReadableStream, options);
+}
+export function ReadableStreamProperty(options) {
+    return createSchemaPropertyDecoratorFromSchema(readableStream(options));
+}

package/schema-old/schemas/regexp.d.ts

@@ -0,0 +1,6 @@
+import type { Decorator } from '../../reflection/index.js';
+import type { Schema } from '../schema.js';
+import type { ValueSchemaOptions } from '../types/types.js';
+export type RegExpSchemaOptions = ValueSchemaOptions;
+export declare function regexp(options?: RegExpSchemaOptions): Schema<RegExp>;
+export declare function RegExpProperty(options?: RegExpSchemaOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/regexp.js

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
+import { valueSchema } from '../types/index.js';
+export function regexp(options) {
+    return valueSchema(RegExp, options);
+}
+export function RegExpProperty(options) {
+    return createSchemaPropertyDecoratorFromSchema(regexp(options));
+}

package/schema-old/schemas/string.d.ts

@@ -0,0 +1,22 @@
+import type { Decorator } from '../../reflection/types.js';
+import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
+export type StringOptions = ValueSchemaOptions & {
+    /** trim */
+    trim?: boolean;
+    /** lowercase */
+    lowercase?: boolean;
+    /** uppercase */
+    uppercase?: boolean;
+    /** minimum length */
+    minimumLength?: number;
+    /** maximum length */
+    maximumLength?: number;
+    /** regular expression */
+    pattern?: string | RegExp;
+    /** regular expression flags */
+    patternFlags?: string;
+    /** name for errors */
+    patternName?: string;
+};
+export declare function string(options?: StringOptions): ValueSchema<string>;
+export declare function StringProperty(options?: StringOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/string.js

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { toArrayCopy } from '../../utils/array/array.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { MaximumLengthConstraint, MinimumLengthConstraint, PatternConstraint } from '../constraints/index.js';
+import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
+import { LowercaseTransformer, TrimTransformer, UppercaseTransformer } from '../transformers/index.js';
+import { valueSchema } from '../types/types.js';
+export function string(options = {}) {
+    const valueConstraints = toArrayCopy(options.valueConstraints ?? []);
+    const transformers = toArrayCopy(options.transformers ?? []);
+    if (isDefined(options.minimumLength)) {
+        valueConstraints.push(new MinimumLengthConstraint(options.minimumLength));
+    }
+    if (isDefined(options.maximumLength)) {
+        valueConstraints.push(new MaximumLengthConstraint(options.maximumLength));
+    }
+    if (isDefined(options.pattern)) {
+        const pattern = RegExp(options.pattern, options.patternFlags);
+        valueConstraints.push(new PatternConstraint(pattern, options.patternName));
+    }
+    if (isDefined(options.trim)) {
+        transformers.push(new TrimTransformer());
+    }
+    if (isDefined(options.lowercase)) {
+        transformers.push(new LowercaseTransformer());
+    }
+    if (isDefined(options.uppercase)) {
+        transformers.push(new UppercaseTransformer());
+    }
+    return valueSchema(String, {
+        ...options,
+        valueConstraints,
+        transformers
+    });
+}
+export function StringProperty(options) {
+    return createSchemaPropertyDecoratorFromSchema(string(options));
+}

package/schema-old/schemas/transform.d.ts

@@ -0,0 +1,5 @@
+import type { OneOrMany } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { GenericTransformFunction } from '../transformers/generic.js';
+import type { ValueSchema, ValueType } from '../types/index.js';
+export declare function transform<T, O>(schema: OneOrMany<SchemaTestable<T>>, transformFunction: GenericTransformFunction<T, O>, sourceType?: OneOrMany<ValueType<T>>): ValueSchema<O>;

package/schema-old/schemas/transform.js

@@ -0,0 +1,7 @@
+import { GenericTransformer } from '../transformers/generic.js';
+import { valueSchema } from '../types/index.js';
+export function transform(schema, transformFunction, sourceType) {
+    return valueSchema(schema, {
+        transformers: new GenericTransformer(transformFunction, sourceType)
+    });
+}

package/schema-old/schemas/uint8-array.d.ts

@@ -0,0 +1,10 @@
+import type { Decorator } from '../../reflection/index.js';
+import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
+export type Uint8ArraySchemaOptions = ValueSchemaOptions & {
+    /** Minimum byte length */
+    minimumLength?: number;
+    /** Maximum byte length */
+    maximumLength?: number;
+};
+export declare function uint8Array(options?: Uint8ArraySchemaOptions): ValueSchema<Uint8Array>;
+export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/uint8-array.js

@@ -0,0 +1,29 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { toArrayCopy } from '../../utils/array/array.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { uint8ArrayCoercer } from '../coercers/uint8-array.coercer.js';
+import { MaximumLengthConstraint } from '../constraints/maximum-length.js';
+import { MinimumLengthConstraint } from '../constraints/minimum-length.js';
+import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
+import { valueSchema } from '../types/types.js';
+export function uint8Array(options = {}) {
+    const coercers = toArrayCopy(options.coercers ?? []);
+    const valueConstraints = toArrayCopy(options.valueConstraints ?? []);
+    if (options.coerce == true) {
+        coercers.push(uint8ArrayCoercer);
+    }
+    if (isDefined(options.minimumLength)) {
+        valueConstraints.push(new MinimumLengthConstraint(options.minimumLength));
+    }
+    if (isDefined(options.maximumLength)) {
+        valueConstraints.push(new MaximumLengthConstraint(options.maximumLength));
+    }
+    return valueSchema(Uint8Array, {
+        ...options,
+        coercers,
+        valueConstraints
+    });
+}
+export function Uint8ArrayProperty(options) {
+    return createSchemaPropertyDecoratorFromSchema(uint8Array(options));
+}

package/schema-old/schemas/union.d.ts

@@ -0,0 +1,7 @@
+import type { Decorator } from '../../reflection/index.js';
+import type { SchemaTestable } from '../schema.js';
+import type { SchemaOutput, ValueSchema, ValueSchemaOptions } from '../types/index.js';
+export type UnionOptions = ValueSchemaOptions;
+export declare function union<T extends SchemaTestable[]>(...schemas: [...T]): ValueSchema<SchemaOutput<T[number]>>;
+export declare function union<T extends SchemaTestable[]>(schemas: [...T], options?: UnionOptions): ValueSchema<SchemaOutput<T[number]>>;
+export declare function Union(...schemas: SchemaTestable[]): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/union.js

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { assert, isArray } from '../../utils/type-guards.js';
+import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
+import { valueSchema } from '../types/index.js';
+export function union(...args) {
+    const schemas = isArray(args[0]) ? args[0] : args;
+    const options = isArray(args[0]) ? args[1] : undefined;
+    assert(schemas.length >= 2, 'Union requires at least 2 schemas.');
+    return valueSchema(schemas, options);
+}
+export function Union(...schemas) {
+    return createSchemaPropertyDecoratorFromSchema(union(...schemas));
+}

package/schema-old/schemas/unknown.d.ts

@@ -0,0 +1,5 @@
+import type { Decorator } from '../../reflection/index.js';
+import { ValueSchema, ValueSchemaOptions } from '../types/index.js';
+export type UnknownOptions = ValueSchemaOptions;
+export declare function unknown(options?: UnknownOptions): ValueSchema<unknown>;
+export declare function UnknownProperty(options?: UnknownOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/unknown.js

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
+import { valueSchema } from '../types/index.js';
+export function unknown(options) {
+    return valueSchema('any', options);
+}
+export function UnknownProperty(options) {
+    return createSchemaPropertyDecoratorFromSchema(unknown(options));
+}

package/templates/resolvers/string.template-resolver.d.ts

@@ -7,7 +7,6 @@ export declare class StringTemplateField<Renderer extends string = string, Optio
     template: StringTemplate<Context>;
 }
 export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
-    constructor();
     canHandle(resolver: string): boolean;
     resolve(field: StringTemplateField): StringTemplate<Record>;
 }

package/templates/resolvers/string.template-resolver.js

@@ -19,9 +19,6 @@ __decorate([
     __metadata("design:type", Object)
 ], StringTemplateField.prototype, "template", void 0);
 let StringTemplateResolver = class StringTemplateResolver extends TemplateResolver {
-    constructor() {
-        super();
-    }
     canHandle(resolver) {
         return (resolver == 'string');
     }
@@ -30,8 +27,7 @@ let StringTemplateResolver = class StringTemplateResolver extends TemplateResolv
     }
 };
 StringTemplateResolver = __decorate([
-    Singleton(),
-    __metadata("design:paramtypes", [])
+    Singleton()
 ], StringTemplateResolver);
 export { StringTemplateResolver };
 export function stringTemplateField(field) {

package/templates/template.model.js

@@ -41,7 +41,7 @@ __decorate([
     __metadata("design:type", String)
 ], Template.prototype, "name", void 0);
 __decorate([
-    Property({ schema: object({}, { unknownProperties: TemplateField }) }),
+    Property(object({}, { unknownProperties: TemplateField })),
     __metadata("design:type", Object)
 ], Template.prototype, "fields", void 0);
 __decorate([

package/types.d.ts

@@ -28,6 +28,7 @@ export type PrimitiveObject = {
 };
 export type PrimitiveArray = PrimitiveValue[];
 export type BuiltIn = Primitive | RegExp | Date | Function;
+export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
 export type Json = JsonPrimitive | JsonObject | JsonArray;
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonObject = {
@@ -156,6 +157,7 @@ export type IfUnknown<T, Then, Else = never> = unknown extends T ? Then : Else;
 export type IsAny<T> = IfAny<T, true, false>;
 export type IsUnknown<T> = IfUnknown<T, true, false>;
 export type If<B extends Boolean, Then, Else> = B extends true ? Then : Else;
+export type Not<T extends boolean> = T extends true ? false : true;
 export type Fallback<T, F> = [T] extends [never] ? F : T;
 export type PartialProperty<T, P extends keyof T> = Omit<T, P> & Partial<Pick<T, P>>;
 export type TypeOf<T extends object, P extends keyof T> = T[P];

package/utils/type-guards.js

@@ -62,7 +62,7 @@ export const assertNullOrUndefined = nullOrUndefinedGuards.assertNullOrUndefined
 export const assertNotNullOrUndefined = nullOrUndefinedGuards.assertNotNullOrUndefined;
 export const assertNullOrUndefinedPass = nullOrUndefinedGuards.assertNullOrUndefinedPass;
 export const assertNotNullOrUndefinedPass = nullOrUndefinedGuards.assertNotNullOrUndefinedPass;
-const numberGuards = createGuards('number', (value) => (typeof value == 'number'));
+const numberGuards = createGuards('number', (value) => (typeof value == 'number') && !Number.isNaN(value));
 export const isNumber = numberGuards.isNumber;
 export const isNotNumber = numberGuards.isNotNumber;
 export const assertNumber = numberGuards.assertNumber;