@tstdl/base 0.92.8 → 0.92.9

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

@@ -8,14 +8,14 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Singleton } from '../../injector/decorators.js';
-import { FunctionProperty } from '../../schema/index.js';
+import { Method } from '../../schema/index.js';
 import { TemplateField, simpleTemplate } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';
 export class JsxTemplateField extends TemplateField {
     template;
 }
 __decorate([
-    FunctionProperty(),
+    Method(null, null),
     __metadata("design:type", Object)
 ], JsxTemplateField.prototype, "template", void 0);
 let JsxTemplateResolver = class JsxTemplateResolver extends TemplateResolver {

package/types.d.ts

@@ -2,6 +2,7 @@ import type { Observable } from 'rxjs';
 import type { CamelCase, Except, IsEqual, LiteralUnion, Tagged, UnwrapTagged } from 'type-fest';
 import type { Signal } from './signals/api.js';
 export type ObjectLiteral = {};
+export type Function<P extends any[] = any[], R = any> = (...params: P) => R;
 export type PrimitiveTypeMap = {
     string: string;
     number: number;
@@ -214,5 +215,4 @@ export type Untagged<T> = T extends Tagged<unknown, any, any> ? UnwrapTagged<T>
 export type UntaggedDeep<T> = T extends Tagged<unknown, any, any> ? UnwrapTagged<T> : T extends readonly (infer U)[] ? UntaggedDeep<U>[] : T extends Record ? {
     [P in keyof T]: UntaggedDeep<T[P]>;
 } : Untagged<T>;
-export type AnyFunction = Function;
 export {};

package/utils/object/lazy-property.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunction, IfUnknown } from '../../types.js';
+import type { Function, IfUnknown } from '../../types.js';
 declare const lazyObjectValueSymbol: unique symbol;
 export type LazyPropertyInitializer<T, K extends keyof T> = (this: T, key: K) => T[K];
 export type LazyPropertyObjectDefinition<T extends object, P extends keyof T> = LazyPropertyDescriptor & {
@@ -15,7 +15,7 @@ export type LazyObjectValue<T> = {
     [lazyObjectValueSymbol]: typeof lazyObjectValueSymbol;
     value: T;
 };
-export type LazyInitializerItem<T extends object, P extends keyof T> = Exclude<IfUnknown<T[P], never, T[P]>, AnyFunction | object> | LazyPropertyInitializer<T, P> | LazyPropertyObjectDefinition<T, P> | LazyObjectValue<T[P]>;
+export type LazyInitializerItem<T extends object, P extends keyof T> = Exclude<IfUnknown<T[P], never, T[P]>, Function | object> | LazyPropertyInitializer<T, P> | LazyPropertyObjectDefinition<T, P> | LazyObjectValue<T[P]>;
 export type LazyPropertyDescriptor = {
     /**
      * True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object

package/utils/object/object.d.ts

@@ -1,5 +1,6 @@
 import { type JsonPathInput } from '../../json-path/json-path.js';
-import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject } from '../../types.js';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types.js';
+export declare function hasOwnProperty<T extends Record, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
  * Returns object entries including those with symbols keys (which Object.entries does not)

package/schema/decorators/property.d.ts

@@ -1,12 +0,0 @@
-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, SchemaTestableProvider } 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: SchemaPropertyDecoratorOptionsWithRequiredSchema): Decorator<'property' | 'accessor'>;
-export declare function PropertySchema(schemaProvider: SchemaTestableProvider, options?: SchemaPropertyDecoratorOptionsWithoutSchema): Decorator<'property' | 'accessor'>;
-export declare function PropertySchema(options: SchemaPropertyDecoratorOptionsWithRequiredSchema): Decorator<'property' | 'accessor'>;

package/schema/decorators/property.js

@@ -1,21 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isDefined, isFunction } from '../../utils/type-guards.js';
-import { createSchemaPropertyDecorator } from './utils.js';
-export function Property(schemaOrOptions, optionsOrNothing) {
-    if (isDefined(optionsOrNothing)) {
-        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: () => schemaOrOptions });
-    }
-    if (isFunction(schemaOrOptions)) {
-        return createSchemaPropertyDecorator({ schema: () => schemaOrOptions });
-    }
-    return createSchemaPropertyDecorator(schemaOrOptions);
-}
-export function PropertySchema(schemaProviderOrOptions, optionsOrNothing) {
-    if (isDefined(optionsOrNothing)) {
-        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: schemaProviderOrOptions });
-    }
-    if (isFunction(schemaProviderOrOptions)) {
-        return createSchemaPropertyDecorator({ schema: schemaProviderOrOptions });
-    }
-    return createSchemaPropertyDecorator(schemaProviderOrOptions);
-}