svelte-kit-vice/src/uix/contracts.ts

import { UIX_REQUIRED_SERVICES } from './active-uix/services';
import type { ActiveApp } from '$active-app';
import type { ActiveDom } from '$adom';
import type { EngineBus } from '$bus';
import type { ActiveEidos } from './eidos/active-eidos.svelte';
import type { ActiveFormat } from '$format';
import type { ActiveLangs } from '$langs';
import type { EngineLogger } from '$logger';
import type { ActivePrefs } from '$prefs';
import type { ActiveTimers } from '$timer';
import type { EngineSemantic } from './sema';
import type { SomaRuntime } from './soma/runtime.svelte';
import type { ActiveUix } from './active-uix/types';
import type { UixRequiredService } from './active-uix/services';

export interface ActiveUixServiceContract {
	readonly langs: ActiveLangs;
	readonly format: ActiveFormat | undefined;
	readonly dom: ActiveDom;
	readonly events: EngineSemantic | undefined;
	readonly logger: EngineLogger;
	readonly bus: EngineBus;
	readonly timers: ActiveTimers;
	readonly prefs: ActivePrefs;
	readonly portal: string | HTMLElement | undefined;
	readonly app: ActiveApp | undefined;
	readonly ownsApp: boolean;
	dispose(): void;
}

export interface SomaRuntimeContract {
	part: SomaRuntime['part'];
	partProps: SomaRuntime['partProps'];
	keydown: SomaRuntime['keydown'];
	trigger: SomaRuntime['trigger'];
}

export interface EventsServiceContract {
	emit: EngineSemantic['emit'];
	dispose: EngineSemantic['dispose'];
}

export interface ActiveEidosRuntimeContract {
	readonly dom: ActiveDom;
	readonly langs: ActiveLangs;
	readonly format: ActiveFormat | undefined;
	readonly prefs: ActivePrefs;
	getThemeId(): string;
	renderStaticCss(): string;
	apply(): void;
	dispose(): void;
}

export interface UixLayerContractTable {
	readonly activeUix: {
		readonly standaloneCreates: readonly string[];
		readonly attachRequires: readonly UixRequiredService[];
		readonly publicSurface: readonly (keyof ActiveUixServiceContract)[];
		readonly forbiddenPublicSurface: readonly string[];
	};
	readonly morfo: {
		readonly role: 'declarative-contract';
		readonly owns: readonly string[];
		readonly createsServices: readonly [];
		readonly translationNamespacePrefix: 'components';
	};
	readonly somaRuntime: {
		readonly role: 'morfo-interpreter';
		readonly requires: readonly ['dom'];
		readonly optional: readonly ['eventEngine', 'translate'];
		readonly publicSurface: readonly (keyof SomaRuntimeContract)[];
		readonly forbiddenPublicSurface: readonly string[];
		readonly createsServices: readonly [];
	};
	readonly events: {
		readonly role: 'perceptual-dispatch';
		readonly publicServiceName: 'events';
		readonly morfoPayloadName: 'semantic';
		readonly requiresOneOfForVisualProjection: readonly ['dom', 'projector'];
		readonly createsServices: readonly [];
	};
	readonly activeEidos: {
		readonly role: 'visual-runtime';
		readonly publicRuntime: 'ActiveEidos';
		readonly forbiddenRuntime: 'EngineEidos';
		readonly requiresForDomApply: readonly ['dom'];
		readonly optionalServices: readonly ['langs', 'format', 'prefs'];
		readonly createsServices: readonly [];
	};
}

export const UIX_LAYER_CONTRACTS = {
	activeUix: {
		standaloneCreates: ['logger', 'bus', 'timers', 'prefs', 'langs', 'dom', 'format', 'events'],
		attachRequires: UIX_REQUIRED_SERVICES,
		publicSurface: [
			'langs',
			'format',
			'dom',
			'events',
			'logger',
			'bus',
			'timers',
			'prefs',
			'portal',
			'app',
			'ownsApp',
			'dispose'
		],
		forbiddenPublicSurface: [
			'lang',
			'semantic',
			'frontend',
			'soma',
			'eidos',
			'somaPortalTo',
			'settings',
			'presentation'
		]
	},
	morfo: {
		role: 'declarative-contract',
		owns: ['parts', 'states', 'props', 'events', 'translations'],
		createsServices: [],
		translationNamespacePrefix: 'components'
	},
	somaRuntime: {
		role: 'morfo-interpreter',
		requires: ['dom'],
		optional: ['eventEngine', 'translate'],
		publicSurface: ['part', 'partProps', 'keydown', 'trigger'],
		forbiddenPublicSurface: ['registerPart', 'createAttrs', 'registerContract'],
		createsServices: []
	},
	events: {
		role: 'perceptual-dispatch',
		publicServiceName: 'events',
		morfoPayloadName: 'semantic',
		requiresOneOfForVisualProjection: ['dom', 'projector'],
		createsServices: []
	},
	activeEidos: {
		role: 'visual-runtime',
		publicRuntime: 'ActiveEidos',
		forbiddenRuntime: 'EngineEidos',
		requiresForDomApply: ['dom'],
		optionalServices: ['langs', 'format', 'prefs'],
		createsServices: []
	}
} as const satisfies UixLayerContractTable;

export type UixLayerContracts = typeof UIX_LAYER_CONTRACTS;

type Extends<T, U> = [T] extends [U] ? true : false;

export const UIX_TYPE_CONTRACTS = {
	activeUix: true,
	somaRuntime: true,
	events: true,
	activeEidos: true
} satisfies {
	activeUix: Extends<ActiveUix, ActiveUixServiceContract>;
	somaRuntime: Extends<SomaRuntime, SomaRuntimeContract>;
	events: Extends<EngineSemantic, EventsServiceContract>;
	activeEidos: Extends<ActiveEidos, ActiveEidosRuntimeContract>;
};