mirror of
https://github.com/hypit-ai/hypit.git
synced 2026-11-17 23:34:00 +08:00
108 lines
3.8 KiB
TypeScript
108 lines
3.8 KiB
TypeScript
import { createResolvedClosure } from "@hypit/kernel";
|
|
import type {
|
|
ModuleManifest,
|
|
ModuleRef,
|
|
ResolvedModuleClosure,
|
|
} from "@hypit/protocol";
|
|
|
|
import { CompilerError } from "./error.js";
|
|
|
|
function moduleKey(ref: ModuleRef): string {
|
|
return `${ref.name}@${ref.version}`;
|
|
}
|
|
|
|
function manifestRef(manifest: ModuleManifest): ModuleRef {
|
|
return { name: manifest.name, version: manifest.version };
|
|
}
|
|
|
|
export type RegisteredModulePackage = {
|
|
readonly manifest: ModuleManifest;
|
|
/** Additional author import spellings resolved to this exact manifest. */
|
|
readonly specifiers?: readonly string[];
|
|
};
|
|
|
|
export interface ModulePackageRegistryLike {
|
|
resolve(request: string): ModuleRef | undefined;
|
|
createClosure(requests: readonly string[]): ResolvedModuleClosure;
|
|
}
|
|
|
|
/**
|
|
* Deterministic registry of already trusted/installed module manifests.
|
|
*
|
|
* This is intentionally not an npm loader: locating and trusting executable package code belongs
|
|
* to the embedding Host. The registry only resolves an author import spelling to one immutable
|
|
* manifest and closes that manifest's declared dependencies.
|
|
*/
|
|
export class ModulePackageRegistry implements ModulePackageRegistryLike {
|
|
readonly #manifests = new Map<string, ModuleManifest>();
|
|
readonly #specifiers = new Map<string, string>();
|
|
|
|
register(value: RegisteredModulePackage): void {
|
|
const ref = manifestRef(value.manifest);
|
|
const key = moduleKey(ref);
|
|
const existing = this.#manifests.get(key);
|
|
if (existing !== undefined) {
|
|
throw new CompilerError("DUPLICATE_MODULE_PACKAGE", `Module package ${key} is already registered`, key);
|
|
}
|
|
const specifiers = new Set([key, ...(value.specifiers ?? [])]);
|
|
for (const specifier of specifiers) {
|
|
if (specifier.length === 0) {
|
|
throw new CompilerError("EMPTY_MODULE_SPECIFIER", `${key} declares an empty import specifier`, key);
|
|
}
|
|
const owner = this.#specifiers.get(specifier);
|
|
if (owner !== undefined) {
|
|
throw new CompilerError(
|
|
"DUPLICATE_MODULE_SPECIFIER",
|
|
`Import ${specifier} is already bound to ${owner}`,
|
|
specifier,
|
|
);
|
|
}
|
|
}
|
|
this.#manifests.set(key, value.manifest);
|
|
for (const specifier of specifiers) this.#specifiers.set(specifier, key);
|
|
}
|
|
|
|
resolve(request: string): ModuleRef | undefined {
|
|
const key = this.#specifiers.get(request);
|
|
const manifest = key === undefined ? undefined : this.#manifests.get(key);
|
|
return manifest === undefined ? undefined : manifestRef(manifest);
|
|
}
|
|
|
|
createClosure(requests: readonly string[]): ResolvedModuleClosure {
|
|
const included = new Map<string, ModuleManifest>();
|
|
const visit = (key: string): void => {
|
|
if (included.has(key)) return;
|
|
const manifest = this.#manifests.get(key);
|
|
if (manifest === undefined) {
|
|
throw new CompilerError("MISSING_MODULE_DEPENDENCY", `Module dependency ${key} is not registered`, key);
|
|
}
|
|
included.set(key, manifest);
|
|
for (const dependency of manifest.dependencies) {
|
|
const dependencyKey = moduleKey(dependency.module);
|
|
const resolved = this.#manifests.get(dependencyKey);
|
|
if (resolved === undefined) {
|
|
throw new CompilerError(
|
|
"MISSING_MODULE_DEPENDENCY",
|
|
`${key} requires unregistered module ${dependencyKey}`,
|
|
dependencyKey,
|
|
);
|
|
}
|
|
visit(dependencyKey);
|
|
}
|
|
};
|
|
|
|
for (const request of [...new Set(requests)].sort()) {
|
|
const key = this.#specifiers.get(request);
|
|
if (key === undefined) {
|
|
throw new CompilerError("UNKNOWN_MODULE_IMPORT", `No registered module satisfies ${request}`, request);
|
|
}
|
|
visit(key);
|
|
}
|
|
return createResolvedClosure(
|
|
[...included.values()].sort((left, right) =>
|
|
moduleKey(manifestRef(left)).localeCompare(moduleKey(manifestRef(right))),
|
|
),
|
|
);
|
|
}
|
|
}
|