@loutrejs/loutre 0.1.0

package/dist/core/provider.d.ts

@@ -0,0 +1,57 @@
+import type { ArgsClass } from './args.js';
+import type { EnvClass } from './env.js';
+import type { RuntimeInputKey } from './runtime-input.js';
+import type { Class, TokenLike, TokenValue } from './token.js';
+export type Scope = 'application' | 'transient';
+interface ProviderBase<TToken extends TokenLike> {
+    readonly provide: TToken;
+    readonly scope: Scope;
+}
+export interface ClassProvider<TToken extends TokenLike = TokenLike, TValue = TokenValue<TToken>> extends ProviderBase<TToken> {
+    readonly kind: 'class';
+    readonly useClass: Class<TValue>;
+}
+export interface ValueProvider<TToken extends TokenLike = TokenLike> extends ProviderBase<TToken> {
+    readonly kind: 'value';
+    readonly useValue: TokenValue<TToken>;
+    readonly scope: 'application';
+}
+export interface FactoryProvider<TToken extends TokenLike = TokenLike> extends ProviderBase<TToken> {
+    readonly kind: 'factory';
+    readonly inject: readonly TokenLike[];
+    readonly useFactory: (...dependencies: any[]) => TokenValue<TToken>;
+}
+export interface ConditionalProvider<TToken extends TokenLike = TokenLike> extends ProviderBase<TToken> {
+    readonly kind: 'conditional';
+    readonly select: RuntimeInputKey<PropertyKey>;
+    readonly mapping: Readonly<Record<PropertyKey, Class<TokenValue<TToken>>>>;
+}
+export interface EnvironmentProvider extends ProviderBase<EnvClass> {
+    readonly kind: 'environment';
+    readonly provide: EnvClass;
+    readonly scope: 'application';
+}
+export interface ArgumentsProvider extends ProviderBase<ArgsClass> {
+    readonly kind: 'arguments';
+    readonly provide: ArgsClass;
+    readonly scope: 'application';
+}
+export type ProviderDescriptor = ClassProvider | ValueProvider | FactoryProvider | ConditionalProvider | EnvironmentProvider | ArgumentsProvider;
+export type ProviderDeclaration = Class | ProviderDescriptor;
+export interface ProviderScopeOptions {
+    readonly scope?: Scope;
+}
+export interface FactoryDefinition<T> extends ProviderScopeOptions {
+    readonly inject?: readonly TokenLike[];
+    readonly use: (...dependencies: any[]) => T;
+}
+export declare function provide<TToken extends TokenLike>(token: TToken): {
+    useClass(implementation: Class<TokenValue<TToken>>, options?: ProviderScopeOptions): ClassProvider<TToken>;
+    useValue(value: TokenValue<TToken>): ValueProvider<TToken>;
+    useFactory(definition: FactoryDefinition<TokenValue<TToken>>): FactoryProvider<TToken>;
+    select<TKey extends PropertyKey>(key: RuntimeInputKey<TKey>, mapping: Readonly<Record<TKey, Class<TokenValue<TToken>>>>, options?: ProviderScopeOptions): ConditionalProvider<TToken>;
+};
+export declare function environmentProvider(environment: EnvClass): EnvironmentProvider;
+export declare function argumentsProvider(argumentsContract: ArgsClass): ArgumentsProvider;
+export declare function normalizeProvider(declaration: ProviderDeclaration): ProviderDescriptor;
+export {};

package/dist/core/provider.js

@@ -0,0 +1,63 @@
+export function provide(token) {
+    return {
+        useClass(implementation, options = {}) {
+            return {
+                kind: 'class',
+                provide: token,
+                useClass: implementation,
+                scope: options.scope ?? 'application',
+            };
+        },
+        useValue(value) {
+            return {
+                kind: 'value',
+                provide: token,
+                useValue: value,
+                scope: 'application',
+            };
+        },
+        useFactory(definition) {
+            return {
+                kind: 'factory',
+                provide: token,
+                inject: definition.inject ?? [],
+                useFactory: definition.use,
+                scope: definition.scope ?? 'application',
+            };
+        },
+        select(key, mapping, options = {}) {
+            return {
+                kind: 'conditional',
+                provide: token,
+                select: key,
+                mapping,
+                scope: options.scope ?? 'application',
+            };
+        },
+    };
+}
+export function environmentProvider(environment) {
+    return {
+        kind: 'environment',
+        provide: environment,
+        scope: 'application',
+    };
+}
+export function argumentsProvider(argumentsContract) {
+    return {
+        kind: 'arguments',
+        provide: argumentsContract,
+        scope: 'application',
+    };
+}
+export function normalizeProvider(declaration) {
+    if (typeof declaration === 'function') {
+        return {
+            kind: 'class',
+            provide: declaration,
+            useClass: declaration,
+            scope: 'application',
+        };
+    }
+    return declaration;
+}

package/dist/core/runtime-input.d.ts

@@ -0,0 +1,11 @@
+import type { TokenLike } from './token.js';
+export type RuntimeInputContract = TokenLike<object> & {
+    readonly name: string;
+};
+export interface RuntimeInputKey<TValue = unknown> {
+    readonly kind: 'runtime-input-key';
+    readonly source: 'environment' | 'arguments';
+    readonly contract: RuntimeInputContract;
+    readonly key: string;
+    readonly '~value'?: TValue;
+}

package/dist/core/runtime-input.js

@@ -0,0 +1 @@
+export {};

package/dist/core/schema.d.ts

@@ -0,0 +1,13 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/spec';
+export type { StandardJSONSchemaV1, StandardSchemaV1, } from '@standard-schema/spec';
+export type StandardSchemaResult<Output> = StandardSchemaV1.Result<Output>;
+export type SchemaOutput<Schema> = Schema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Schema> : never;
+export type SchemaInput<Schema> = Schema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<Schema> : never;
+export type JsonSchemaInput<Schema> = Schema extends StandardJSONSchemaV1 ? StandardJSONSchemaV1.InferInput<Schema> : never;
+export type JsonSchemaOutput<Schema> = Schema extends StandardJSONSchemaV1 ? StandardJSONSchemaV1.InferOutput<Schema> : never;
+export declare function supportsJsonSchema(schema: StandardSchemaV1): schema is StandardSchemaV1 & StandardJSONSchemaV1;
+export declare function validateSchema<Schema extends StandardSchemaV1>(schema: Schema, value: unknown): Promise<SchemaOutput<Schema>>;
+export declare class SchemaValidationError extends Error {
+    readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+    constructor(issues: SchemaValidationError['issues']);
+}

package/dist/core/schema.js

@@ -0,0 +1,20 @@
+export function supportsJsonSchema(schema) {
+    const standard = schema['~standard'];
+    return (typeof standard.jsonSchema?.input === 'function' &&
+        typeof standard.jsonSchema.output === 'function');
+}
+export async function validateSchema(schema, value) {
+    const result = await schema['~standard'].validate(value);
+    if (result.issues) {
+        throw new SchemaValidationError(result.issues);
+    }
+    return result.value;
+}
+export class SchemaValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super('Schema validation failed');
+        this.name = 'SchemaValidationError';
+        this.issues = issues;
+    }
+}

package/dist/core/token.d.ts

@@ -0,0 +1,16 @@
+export interface TokenOptions {
+    readonly description?: string;
+}
+export interface Token<T> {
+    readonly kind: 'token';
+    readonly id: string;
+    readonly description?: string;
+    readonly key: symbol;
+    readonly '~type'?: T;
+}
+export type Class<T = unknown> = new (...args: any[]) => T;
+export type AbstractClass<T = unknown> = abstract new (...args: any[]) => T;
+export type TokenLike<T = unknown> = Token<T> | AbstractClass<T>;
+export type TokenValue<TToken> = TToken extends Token<infer Value> ? Value : TToken extends AbstractClass<infer Value> ? Value : never;
+export declare function token<T>(id: string, options?: TokenOptions): Token<T>;
+export declare function tokenName(value: TokenLike): string;

package/dist/core/token.js

@@ -0,0 +1,13 @@
+export function token(id, options = {}) {
+    return Object.freeze({
+        kind: 'token',
+        id,
+        ...(options.description === undefined
+            ? {}
+            : { description: options.description }),
+        key: Symbol(id),
+    });
+}
+export function tokenName(value) {
+    return typeof value === 'function' ? value.name : value.id;
+}

package/dist/graph/graph.d.ts

@@ -0,0 +1,17 @@
+import { type ArgsClass, type ModuleInstance, type ModuleTemplate, type TaskDescriptor, type TriggerDescriptor } from '../core/index.js';
+import type { ApplicationGraphIR, CompilationResult, Diagnostic } from './ir.js';
+export declare class StaticValidationError extends Error {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly graph?: ApplicationGraphIR | undefined;
+    constructor(diagnostics: readonly Diagnostic[], graph?: ApplicationGraphIR | undefined);
+}
+export interface ApplicationCompilationInput {
+    readonly modules: readonly (ModuleInstance | ModuleTemplate<void>)[];
+    readonly arguments?: ArgsClass | undefined;
+    readonly tasks?: readonly TaskDescriptor<any, any>[];
+    readonly triggers?: readonly TriggerDescriptor[];
+}
+export declare function compileApplication(input: ApplicationCompilationInput): CompilationResult;
+export declare const buildApplicationGraph: typeof compileApplication;
+export declare function validateGraph(graph: ApplicationGraphIR): readonly Diagnostic[];
+export declare function assertValidCompilation(result: CompilationResult): ApplicationGraphIR;