@tstdl/base 0.92.124 → 0.92.125

package/serializer/types.d.ts

@@ -0,0 +1,65 @@
+import type { AbstractConstructor, JsonPrimitive, Nested, Record } from '../types.js';
+declare const serializedSymbol: unique symbol;
+declare const stringSerializedSymbol: unique symbol;
+declare const decycledSymbol: unique symbol;
+export type SerializationReplacer = (value: any, data?: Record) => any;
+export type TypeField<T extends string> = `<${T}>`;
+export type NonPrimitive<TypeName extends string = string, Data = unknown> = Record<TypeField<TypeName>, Data>;
+export type RawNonPrimitive = NonPrimitive<typeof rawNonPrimitiveType, any>;
+export type UndefinedNonPrimitive = NonPrimitive<typeof undefinedNonPrimitiveType, null>;
+export type BigintNonPrimitive = NonPrimitive<typeof bigintNonPrimitiveType, string>;
+export type GlobalSymbolNonPrimitive = NonPrimitive<typeof globalSymbolNonPrimitiveType, string>;
+export type FunctionNonPrimitive = NonPrimitive<typeof functionNonPrimitiveType, string>;
+export type RefNonPrimitive = NonPrimitive<typeof refNonPrimitiveType, string>;
+export type CustomNonPrimitive<TypeName extends string> = NonPrimitive<TypeName, SerializedData>;
+export type SerializedData = JsonPrimitive | NonPrimitive | Nested<JsonPrimitive | NonPrimitive>;
+export type Serialized<T = unknown> = SerializedData & {
+    [serializedSymbol]: T;
+};
+export type StringSerialized<T = unknown> = string & {
+    [stringSerializedSymbol]: T;
+};
+export type Decycled<T = unknown> = {
+    [decycledSymbol]: T;
+};
+export type SerializationOptions = {
+    /**
+     * !!! DANGEROUS !!!
+     *
+     * Enable de/serialization of stuff like functions
+     *
+     * Remote code execution possible, source must be trusted!
+     * @default false
+     */
+    allowUnsafe?: boolean;
+    /**
+     * Every replacer is called with every value and the value is replaced with its return value.
+     */
+    replacers?: SerializationReplacer[];
+    /**
+     * Constructors to not serialze (keep raw)
+     */
+    raws?: AbstractConstructor[];
+    /**
+     * Context for references. Can be used to reduce serialized size, if data is available at deserialization and to be able to reference abitrary data which is not serializable like non-global symbols
+     *
+     * Only first level of object is referenced. For example for `{ foo: { bar: 'baz' } }` there will be one context entry having { bar: 'baz' }
+     */
+    context?: Record;
+    /**
+     * Disables dereferencing of ForwardRefs. Only useful for debugging (when implementing custom serializers) and curiosity
+     * @default false
+     */
+    doNotDereferenceForwardRefs?: boolean;
+    /**
+     * Data to be used on de/serialization handlers and replacers
+     */
+    data?: Record;
+};
+export declare const rawNonPrimitiveType = "raw";
+export declare const undefinedNonPrimitiveType = "undefined";
+export declare const bigintNonPrimitiveType = "bigint";
+export declare const globalSymbolNonPrimitiveType = "global-symbol";
+export declare const functionNonPrimitiveType = "function";
+export declare const refNonPrimitiveType = "ref";
+export {};

package/sse/server-sent-events-source.d.ts

@@ -0,0 +1,12 @@
+import type { ServerSentJsonEvent, ServerSentTextEvent } from './model.js';
+export declare class ServerSentEventsSource {
+    #private;
+    readonly readable: ReadableStream<string>;
+    readonly closed: import("../signals/api.js").Signal<boolean>;
+    readonly error: import("../signals/api.js").Signal<Error | undefined>;
+    constructor();
+    close(): Promise<void>;
+    sendComment(comment: string): Promise<void>;
+    sendText({ name, data, id, retry }: ServerSentTextEvent): Promise<void>;
+    sendJson({ name, data, id, retry }: ServerSentJsonEvent): Promise<void>;
+}

package/templates/module.d.ts

@@ -0,0 +1,14 @@
+import type { Type } from '../types.js';
+import { TemplateProvider } from './template.provider.js';
+import { TemplateRenderer } from './template.renderer.js';
+import { TemplateResolver } from './template.resolver.js';
+export type TemplateModuleConfig = {
+    templateProvider: Type<TemplateProvider> | undefined;
+    templateResolvers: Type<TemplateResolver>[];
+    templateRenderers: Type<TemplateRenderer>[];
+};
+export declare const templateModuleConfig: TemplateModuleConfig;
+/**
+ * configure mail module
+ */
+export declare function configureTemplates(config?: Partial<TemplateModuleConfig>): void;

package/templates/providers/file.template-provider.d.ts

@@ -0,0 +1,15 @@
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { Template } from '../template.model.js';
+import { TemplateProvider } from '../template.provider.js';
+export type FileTemplateProviderConfig = {
+    basePath?: string;
+};
+export type FileTemplateProviderArgument = string;
+export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
+export declare class FileTemplateProvider extends TemplateProvider implements Resolvable<FileTemplateProviderArgument> {
+    private readonly basePath;
+    readonly [resolveArgumentType]: FileTemplateProviderArgument;
+    constructor(basePath: string);
+    get<T extends Template = Template>(key: string): Promise<T>;
+}
+export declare function configureFileTemplateProvider(config?: Partial<FileTemplateProviderConfig>): void;

package/templates/renderers/handlebars.template-renderer.d.ts

@@ -0,0 +1,43 @@
+import type { ObjectLiteral, Record } from '../../types.js';
+import type * as Handlebars from 'handlebars';
+import { TemplateResolverProvider } from '../template-resolver.provider.js';
+import type { TemplateField } from '../template.model.js';
+import type { TemplateRenderObject } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type HandlebarsTemplateHelperOptionsLocationItem = {
+    line: number;
+    column: number;
+};
+export type HandlebarsTemplateHelperOptionsLocation = {
+    start: HandlebarsTemplateHelperOptionsLocationItem;
+    end: HandlebarsTemplateHelperOptionsLocationItem;
+};
+export type HandlebarsTemplateHelperOptions = {
+    name: string;
+    location?: HandlebarsTemplateHelperOptionsLocation;
+    data?: Record<string>;
+    hash: Record<string>;
+    lookupProperty: (object: ObjectLiteral, propertyName: string) => unknown;
+    fn?: Handlebars.TemplateDelegate;
+    inverse?: Handlebars.TemplateDelegate;
+};
+export type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
+export type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
+export type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | Handlebars.TemplateDelegate;
+export type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
+export type HandlebarsRendererOptions = {
+    strict?: boolean;
+    preventIndent?: boolean;
+    helpers?: HandlebarsTemplateHelpersObject;
+    partials?: HandlebarsTemplatePartialsObject;
+};
+export type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
+export declare class HandlebarsTemplateRenderer extends TemplateRenderer<'handlebars', HandlebarsRendererOptions> {
+    private readonly templateResolverProvider;
+    private readonly compileHandlebarsTemplate;
+    constructor(templateResolverProvider: TemplateResolverProvider);
+    canHandleType(type: string): boolean;
+    _render(renderObject: HandlebarsTemplateRenderObject, context: Record): Promise<string>;
+    private _compileHandlebarsTemplate;
+    private normalizePartial;
+}

package/templates/renderers/jsx.template-renderer.d.ts

@@ -0,0 +1,10 @@
+import type { Record } from '../../types.js';
+import type { JsxTemplate } from '../resolvers/jsx.template-resolver.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type JsxTemplateRenderObject = TemplateRenderObject<'jsx', undefined, JsxTemplate>;
+export declare class JsxTemplateRenderer extends TemplateRenderer<'jsx', undefined> {
+    constructor();
+    canHandleType(type: string): boolean;
+    _render({ template }: JsxTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
+}

package/templates/renderers/mjml.template-renderer.d.ts

@@ -0,0 +1,16 @@
+import type { Record } from '../../types.js';
+import type { MJMLParsingOptions } from 'mjml-core';
+import { TemplateRendererProvider } from '../template-renderer.provider.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
+    preprocessorOptions?: any;
+};
+export type MjmlRendererString = 'mjml' | `mjml-${string}`;
+export type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions, string>;
+export declare class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererString, MjmlRendererOptions> {
+    private readonly rendererProvider;
+    constructor(rendererProvider: TemplateRendererProvider);
+    canHandleType(type: string): boolean;
+    _render({ renderer, template, options }: MjmlTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
+}

package/templates/renderers/string.template-renderer.d.ts

@@ -0,0 +1,10 @@
+import type { Record } from '../../types.js';
+import type { StringTemplate } from '../resolvers/string.template-resolver.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined, StringTemplate>;
+export declare class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
+    constructor();
+    canHandleType(type: string): boolean;
+    _render({ template }: StringTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
+}

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

@@ -0,0 +1,22 @@
+import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import type { TypedOmit } from '../../types.js';
+import { TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+export type FileTemplateProviderConfig = {
+    basePath?: string;
+};
+export type FileTemplateProviderArgument = string;
+export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
+export declare class FileTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'file', Renderer, Options> {
+    templateFile: string;
+}
+export declare class FileTemplateResolver extends TemplateResolver<FileTemplateField> implements Resolvable<FileTemplateProviderArgument> {
+    private readonly basePath;
+    readonly [resolveArgumentType]: FileTemplateProviderArgument;
+    constructor(basePath: string);
+    canHandle(resolver: string): boolean;
+    resolve(field: FileTemplateField): Promise<string>;
+}
+export declare function fileTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
+export declare function configureFileTemplateResolver(config?: Partial<FileTemplateProviderConfig>): void;

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

@@ -0,0 +1,17 @@
+import type { PartialProperty, Record, TypedOmit } from '../../types.js';
+import type { ComponentClass, FunctionComponent } from 'preact';
+import { type Template, TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
+export declare class JsxTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: JsxTemplate<Context>;
+}
+export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
+    canHandle(resolver: string): boolean;
+    resolve(field: JsxTemplateField): JsxTemplate;
+}
+export declare function jsxTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: PartialProperty<TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>, 'renderer'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;
+export declare function simpleJsxTemplate<Context extends Record = any>(name: string, template: JsxTemplate<Context>): Template<{
+    template: true;
+}, undefined, Context>;

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

@@ -0,0 +1,13 @@
+import type { Record, TypedOmit } from '../../types.js';
+import { TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+export type StringTemplate<Context extends Record = any> = string | ((context: Context) => string | Promise<string>);
+export declare class StringTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: StringTemplate<Context>;
+}
+export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
+    canHandle(resolver: string): boolean;
+    resolve(field: StringTemplateField): StringTemplate<Record>;
+}
+export declare function stringTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

package/templates/template.model.d.ts

@@ -0,0 +1,25 @@
+import type { PickBy, Record, SimplifyObject } from '../types.js';
+export type TemplateContext<T extends Template> = Parameters<NonNullable<T[typeof templateContext]>>[0];
+declare const templateContext: unique symbol;
+export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
+    resolver: Resolver;
+    renderer: Renderer;
+    options?: Options;
+}
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> = SimplifyObject<{
+    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options, Context>;
+} & {
+    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options, Context>;
+}>;
+export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
+    /** Name of template */
+    name: string;
+    fields: TemplateFields<Fields, string, string, any, Context>;
+    options?: TemplateOptions;
+}
+export declare function simpleTemplate<Context extends Record = any, Options = any>(name: string, template: TemplateField<string, string, any, Context>, options?: Options): Template<{
+    template: true;
+}, Options, Context>;
+export {};

package/templates/template.renderer.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaTestable } from '../schema/index.js';
+import type { Record } from '../types.js';
+export type TemplateRenderResult = string;
+export type TemplateRenderObject<Renderer extends string = string, Options = any, V = unknown> = {
+    renderer: Renderer;
+    template: V;
+    contextSchema?: SchemaTestable<Record>;
+    options?: Options;
+};
+export type TemplateRendererString = typeof templateRendererString;
+export type TemplateRendererOptions = typeof templateRendererOptions;
+export declare const templateRendererString: unique symbol;
+export declare const templateRendererOptions: unique symbol;
+export declare abstract class TemplateRenderer<Renderer extends string = string, Options = any> {
+    readonly [templateRendererString]: Renderer;
+    readonly [templateRendererOptions]: Options;
+    render(template: TemplateRenderObject<Renderer, Options>, context?: Record): Promise<TemplateRenderResult>;
+    abstract canHandleType(type: string): boolean;
+    protected abstract _render(renderObject: TemplateRenderObject<Renderer, Options>, context: Record): TemplateRenderResult | Promise<TemplateRenderResult>;
+}

package/templates/template.service.d.ts

@@ -0,0 +1,18 @@
+import type { Record } from '../types.js';
+import { TemplateRendererProvider } from './template-renderer.provider.js';
+import { TemplateResolverProvider } from './template-resolver.provider.js';
+import type { Template, TemplateContext } from './template.model.js';
+import { TemplateProvider } from './template.provider.js';
+export type TemplateServiceRenderResult<T extends Template = Template> = {
+    name: string;
+    fields: Record<keyof T['fields'], string>;
+    options: T['options'];
+};
+export declare class TemplateService {
+    private readonly templateProvider;
+    private readonly templateRendererProvider;
+    private readonly templateResolverProvider;
+    constructor(templateProvider: TemplateProvider | undefined, templateRendererProvider: TemplateRendererProvider, templateResolverProvider: TemplateResolverProvider);
+    get<T extends Template = Template>(key: string): Promise<T>;
+    render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: TemplateContext<T>): Promise<TemplateServiceRenderResult<T>>;
+}

package/templates/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { TemplateRenderer } from './template.renderer.js';
+import type { TemplateResolver } from './template.resolver.js';
+export declare const TEMPLATE_RENDERERS: import("../injector/token.js").InjectionToken<TemplateRenderer<string, any>[], never>;
+export declare const TEMPLATE_RESOLVERS: import("../injector/token.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any, any>, unknown>[], never>;

package/text/dynamic-text.model.d.ts

@@ -0,0 +1,15 @@
+import { type Observable } from 'rxjs';
+import { type Signal } from '../signals/api.js';
+import type { PickBy, ReactiveValue, ReplaceKey } from '../types.js';
+import type { LocalizableText } from './localizable-text.model.js';
+import { LocalizationService } from './localization.service.js';
+export type DynamicText = ReactiveValue<LocalizableText>;
+export declare const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
+export declare function resolveDynamicText(text: DynamicText, localizationService?: LocalizationService): Signal<string>;
+export declare function resolveDynamicText$(text: DynamicText, localizationService?: LocalizationService): Observable<string>;
+export declare function resolveDynamicTexts(texts: DynamicText[], localizationService?: LocalizationService): Signal<string[]>;
+export declare function resolveDynamicTexts$(texts: DynamicText[], localizationService?: LocalizationService): Observable<string[]>;
+export declare function resolveNestedDynamicText<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>>;
+export declare function resolveNestedDynamicText$<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>>;
+export declare function resolveNestedDynamicTexts<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>[]>;
+export declare function resolveNestedDynamicTexts$<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>[]>;

package/text/localization.service.d.ts

@@ -0,0 +1,92 @@
+import type { Observable } from 'rxjs';
+import { Logger } from '../logger/index.js';
+import type { Signal } from '../signals/api.js';
+import type { Enumeration, EnumerationValue, Record } from '../types.js';
+import type { PropertyName } from '../utils/object/property-name.js';
+export type Language = {
+    code: string;
+    name: string;
+};
+export type LocalizeFunctionContext = {
+    localizationService: LocalizationService;
+};
+export type LocalizeFunction<Parameters = void> = (parameters: Parameters, context: LocalizeFunctionContext) => string;
+export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
+type LocalizationTemplate = {
+    [key: string]: LocalizeItem<any> | LocalizationTemplate;
+};
+export type EnumerationLocalization<T extends Enumeration = Enumeration> = Record<EnumerationValue<T>, LocalizeItem<any>>;
+export type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [enumType: T, enumName: LocalizeItem<any> | undefined, enumValues: EnumerationLocalization<T>];
+export type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = Enumeration[]> = {
+    language: Language;
+    keys: T;
+    enums: {
+        [I in keyof Enums]: EnumerationLocalizationEntry<Enums[I]>;
+    };
+};
+declare const parametersSymbol: unique symbol;
+export type ProxyLocalizationKey<Parameters = void> = PropertyName & {
+    [parametersSymbol]?: Parameters;
+};
+export type LocalizationKey<Parameters = void> = string | ProxyLocalizationKey<Parameters>;
+export type EnumLocalizationKey<T extends Enumeration = Enumeration, Parameters = void> = Parameters extends void ? {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters?: void;
+} : {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters: Parameters;
+};
+export type LocalizationData<Parameters = any, E extends Enumeration = any> = LocalizationKey | EnumLocalizationKey<E, Parameters> | LocalizationDataObject<Parameters> | {
+    key: LocalizationKey;
+    parameters?: void;
+};
+export type LocalizationDataObject<Parameters> = {
+    key: LocalizationKey<Parameters>;
+    parameters: Parameters;
+};
+export type ProxyLocalizationKeys<T extends LocalizationTemplate> = {
+    [P in keyof T]: T[P] extends LocalizationTemplate ? ProxyLocalizationKeys<T[P]> : T[P] extends LocalizeItem<infer R> ? ProxyLocalizationKey<R> : ProxyLocalizationKey;
+};
+export declare function getProxyLocalizationKey<Parameters = void>(key: string): ProxyLocalizationKey<Parameters>;
+export declare function isProxyLocalizationKey(value: any): value is ProxyLocalizationKey;
+export declare function isEnumLocalizationKey(key: any): key is EnumLocalizationKey;
+export declare function isLocalizationDataObject(value: LocalizationData): value is LocalizationDataObject<any>;
+/** helper function to ensure type safety */
+export declare function localizationData<T>(key: LocalizationKey<T>, parameters: T): LocalizationDataObject<T>;
+export declare function localizationData<T>(data: LocalizationData<T>): LocalizationDataObject<T>;
+/**
+ * returns a Proxy which simply returns the key you accessed. Can be used to have typesafe localizations (in templates and the API) by not relying on plain strings
+ * @param localization
+ * @returns
+ */
+export declare function getLocalizationKeys<T extends Localization>(_localization?: T): ProxyLocalizationKeys<T['keys']>;
+export declare const autoEnumerationLocalization: typeof _autoEnumerationLocalization;
+export declare class LocalizationService {
+    #private;
+    readonly activeLanguage: Signal<Language | null>;
+    readonly availableLanguages: Signal<Language[]>;
+    readonly activeLanguage$: Observable<Language | null>;
+    readonly availableLanguages$: Observable<Language[]>;
+    constructor(logger: Logger);
+    registerLocalization(...localizations: Localization[]): void;
+    hasLanguage(languageCode: string): boolean;
+    getLanguage(languageCode: string): Language;
+    setLanguage(languageOrCode: Language | string): void;
+    setLocalization(localization: Localization): void;
+    tryGetItem<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
+    hasKey<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): boolean;
+    localizeOnce<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
+    localizeEnumOnce<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
+    localize<Parameters>(data: LocalizationData<Parameters>): Signal<string>;
+    localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Signal<string>;
+    localize$<Parameters>(data: LocalizationData<Parameters>): Observable<string>;
+    localizeEnum$<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Observable<string>;
+    private localizeItem;
+}
+export declare function enumerationLocalization<T extends Enumeration>(enumeration: T, name: LocalizeItem | undefined, localization: EnumerationLocalization<T>): EnumerationLocalizationEntry<T>;
+export declare function enumerationLocalization<T extends Enumeration>(enumeration: T, localization: EnumerationLocalization<T>): EnumerationLocalizationEntry<T>;
+declare function _autoEnumerationLocalization<T extends Enumeration>(enumeration: T, name?: LocalizeItem): EnumerationLocalizationEntry<T>;
+export declare function isLocalizeItem(value: any): value is LocalizeItem<any>;
+export {};

package/theme/adapters/tailwind-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { Theme } from '../../theme/theme-service.js';
+export type TailwindPalette = {
+    DEFAULT: string;
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+    950: string;
+};
+export declare function generateTailwindColorsFromTheme(theme: Theme, tailwindNamePrefix?: string): Record<string, TailwindPalette>;
+export declare function generateTailwindColorsFromThemeColors(colors: readonly string[], tailwindNamePrefix?: string): Record<string, TailwindPalette>;
+export declare function generateTailwindPalette(color: string): TailwindPalette;

package/theme/theme-service.d.ts

@@ -0,0 +1,43 @@
+import { type Observable } from 'rxjs';
+export type CalculatedPalette<Colors extends string = string> = {
+    [Color in Colors]: ColorTonesWithRgb;
+};
+export type CalculatedTheme<Colors extends string = string> = {
+    palette: CalculatedPalette<Colors>;
+};
+export type Theme<Colors extends string = string> = {
+    palette: Palette<Colors>;
+};
+export type Palette<Colors extends string = string> = {
+    [Color in Colors]: string | ColorTones;
+};
+export type ColorTones = {
+    base: string;
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+};
+export type ColorTonesWithRgb = ColorTones & {
+    [Tone in keyof ColorTones as `${Tone}Rgb`]: string;
+};
+export declare const themeColorTones: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+export declare const DEFAULT_THEME: import("../injector/token.js").InjectionToken<Theme<string>, never>;
+export declare class ThemeService<Colors extends string = string> {
+    private readonly themeSubject;
+    private readonly calculatedThemeSubject;
+    private readonly defaultTheme;
+    readonly colors: Colors[];
+    readonly theme$: Observable<Theme<Colors>>;
+    readonly calculatedTheme$: Observable<CalculatedTheme<Colors>>;
+    get theme(): Theme<Colors>;
+    get calculatedTheme(): CalculatedTheme<Colors>;
+    constructor(defaultTheme: Theme<Colors>);
+    setTheme(theme?: Theme<Colors> | undefined): void;
+}

package/threading/thread-pool.d.ts

@@ -0,0 +1,20 @@
+import type * as NodeWorkerThreads from 'node:worker_threads';
+import type { LiteralUnion } from 'type-fest';
+import type { AsyncDisposable } from '../disposable/index.js';
+import { disposeAsync } from '../disposable/index.js';
+import type { Logger } from '../logger/index.js';
+import type { ThreadWorker } from './thread-worker.js';
+export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
+    threadCount?: number;
+};
+export declare class ThreadPool implements AsyncDisposable {
+    private readonly pool;
+    readonly url: string | URL;
+    readonly options: ThreadOptions | undefined;
+    constructor(url: string | URL, logger: Logger, options?: ThreadOptions);
+    dispose(): Promise<void>;
+    [disposeAsync](): Promise<void>;
+    getProcessor<T extends ThreadWorker>(name?: string): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+    process<T extends ThreadWorker>(name: LiteralUnion<'default', string>, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    private spawn;
+}

package/types/geo-json.d.ts

@@ -0,0 +1,36 @@
+import type { JsonObject } from '../types.js';
+export type Position = [longitude: number, latitude: number, elevation?: number];
+export type GeoJsonObject<Type extends string> = {
+    type: Type;
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number];
+};
+export type Point = GeoJsonObject<'Point'> & {
+    coordinates: Position;
+};
+export type LineString = GeoJsonObject<'LineString'> & {
+    coordinates: Position[];
+};
+export type Polygon = GeoJsonObject<'Polygon'> & {
+    coordinates: Position[][];
+};
+export type MultiPoint = GeoJsonObject<'MultiPoint'> & {
+    coordinates: Position[];
+};
+export type MultiLineString = GeoJsonObject<'MultiLineString'> & {
+    coordinates: Position[][];
+};
+export type MultiPolygon = GeoJsonObject<'MultiPolygon'> & {
+    coordinates: Position[][][];
+};
+export type GeometryCollection = GeoJsonObject<'GeometryCollection'> & {
+    geometries: Geometry[];
+};
+export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon | GeometryCollection;
+export type Feature<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'Feature'> & {
+    id?: string | number;
+    geometry: G;
+    properties: P;
+};
+export type FeatureCollection<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'FeatureCollection'> & {
+    features: Feature<G, P>[];
+};

package/types/index.d.ts

@@ -1,8 +1,2 @@
-/**
- * Core of tstdl
- *
- * @module Core
- */
-export * from './core.js';
-export * from './import.js';
-export * from './require.js';
+export type * from './geo-json.js';
+export type * from './tagged.js';

package/types/tagged.d.ts

@@ -0,0 +1,16 @@
+import type { Record } from '../types.js';
+export declare const tag: unique symbol;
+export declare const type: unique symbol;
+export type TagContainer<Type, Token> = {
+    readonly [tag]?: Token;
+    readonly [type]?: Type;
+};
+export type Tag<Type, Token extends PropertyKey, TagMetadata> = TagContainer<Type, Record<Token, TagMetadata>>;
+export type HasTag<T, Token = unknown> = T extends TagContainer<unknown, Token> ? true : false;
+export type Tagged<Type = unknown, TagName extends PropertyKey = PropertyKey, TagMetadata = unknown> = Type & Tag<Type, TagName, TagMetadata>;
+export type GetTagMetadata<Type extends Tag<unknown, TagName, unknown>, TagName extends PropertyKey> = NonNullable<Type[typeof tag]>[TagName];
+export type UnwrapTagged<TaggedType extends Tag<unknown, PropertyKey, any>> = TaggedType extends Tagged<infer Type, PropertyKey, any> ? Type : never;
+export type Untagged<T> = T extends Tagged ? UnwrapTagged<T> : T;
+export type UntaggedDeep<T> = Untagged<T> extends any[] | Record ? {
+    [P in keyof Untagged<T>]: UntaggedDeep<Untagged<T>[P]>;
+} : Untagged<T>;

package/utils/async-iterable-helpers/take-until.d.ts

@@ -0,0 +1,3 @@
+import type { CancellationSignal } from '../../cancellation/token.js';
+import type { AnyIterable } from '../any-iterable-iterator.js';
+export declare function takeUntilAsync<T>(iterable: AnyIterable<T>, cancellationSignal: CancellationSignal): AsyncIterableIterator<T>;