@ykdz/template 0.0.42 → 0.1.0-experimental.1

package/node_modules/@ykdz/template-generator/dist/content-source.js

@@ -0,0 +1,181 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { isDeepStrictEqual } from "node:util";
+import { createContentIndex, } from "@ykdz/template-core/content-identity";
+/** 经来源自己的Node解析器，从公开代码与数据入口装载本次内容集合。 */
+export async function loadContentSource(options) {
+    if (options.namespace.trim().length === 0) {
+        throw new Error("内容来源命名空间不能为空");
+    }
+    const members = await Promise.all(options.members.map(async (specifier) => await loadMember(options, specifier)));
+    createContentIndex(members);
+    return Object.freeze(members);
+}
+async function loadMember(options, specifier) {
+    const address = publicSpecifierAddress(specifier);
+    const resolvedModuleURL = resolveLocalURL(options.resolve, specifier, "代码入口");
+    const resolvedManifestURL = resolveLocalURL(options.resolve, `${address.packageName}/reference`, "原生清单入口");
+    const [moduleNamespace, manifestNamespace] = await Promise.all([
+        import(__rewriteRelativeImportExtension(resolvedModuleURL)),
+        import(__rewriteRelativeImportExtension(resolvedManifestURL), { with: { type: "json" } }),
+    ]);
+    const manifestValue = isRecord(manifestNamespace)
+        ? manifestNamespace.default
+        : undefined;
+    const manifest = assertNativeManifest(manifestValue, specifier);
+    if (manifest.name !== address.packageName) {
+        throw new Error(`内容${specifier}的原生清单包名不匹配：预期${address.packageName}，实际${manifest.name}`);
+    }
+    if (!Object.hasOwn(manifest.exports, address.exportPath)) {
+        throw new Error(`内容${specifier}未由原生清单公开导出入口${address.exportPath}`);
+    }
+    const loaded = await primaryDefinition(moduleNamespace, options.prepareReferenceDefinition, specifier);
+    if (loaded.kind === "reference") {
+        if (!isDeepStrictEqual(loaded.definition.manifest, manifest)) {
+            throw new Error(`内容${specifier}的参考包准备结果与原生清单不一致`);
+        }
+    }
+    else if (loaded.definition.owner !== undefined &&
+        (loaded.definition.owner.packageName !== manifest.name ||
+            loaded.definition.owner.exportPath !== address.exportPath)) {
+        throw new Error(`预设${specifier}的所属入口与实际公开内容入口不一致`);
+    }
+    const identity = Object.freeze({
+        namespace: options.namespace,
+        packageName: manifest.name,
+        exportPath: address.exportPath,
+    });
+    return Object.freeze({
+        identity,
+        kind: loaded.kind,
+        alias: loaded.alias,
+        definition: loaded.definition,
+        source: Object.freeze({
+            specifier,
+            moduleURL: resolvedModuleURL,
+            manifestURL: resolvedManifestURL,
+        }),
+    });
+}
+async function primaryDefinition(moduleNamespace, prepareReferenceDefinition, specifier) {
+    if (!isRecord(moduleNamespace)) {
+        throw new Error(`内容${specifier}的公开代码入口未导出对象`);
+    }
+    const candidates = [];
+    if (Object.hasOwn(moduleNamespace, "preset")) {
+        candidates.push({ kind: "preset", value: moduleNamespace.preset });
+    }
+    if (Object.hasOwn(moduleNamespace, "referencePackage")) {
+        candidates.push({
+            kind: "reference",
+            value: moduleNamespace.referencePackage,
+        });
+    }
+    if (Object.hasOwn(moduleNamespace, "referenceDefinition")) {
+        candidates.push({
+            kind: "reference",
+            value: moduleNamespace.referenceDefinition,
+        });
+    }
+    if (candidates.length !== 1) {
+        throw new Error(`内容${specifier}必须只公开一个预设或参考包主定义`);
+    }
+    const candidate = candidates[0];
+    if (candidate.kind === "preset") {
+        if (!isRecord(candidate.value) ||
+            candidate.value.kind !== "preset" ||
+            !isRecord(candidate.value.metadata)) {
+            throw new Error(`内容${specifier}的公开定义不是预设`);
+        }
+        const definition = candidate.value;
+        return {
+            kind: "preset",
+            alias: requireAlias(definition.metadata.alias, specifier),
+            definition,
+        };
+    }
+    let definition = candidate.value;
+    if (Object.hasOwn(moduleNamespace, "referenceDefinition")) {
+        if (prepareReferenceDefinition === undefined) {
+            throw new Error(`内容${specifier}公开raw参考声明，但来源未提供正式准备函数`);
+        }
+        definition = prepareReferenceDefinition(definition);
+    }
+    if (!isPreparedReference(definition)) {
+        throw new Error(`内容${specifier}的公开定义不是已准备参考包`);
+    }
+    return {
+        kind: "reference",
+        alias: requireAlias(definition.alias, specifier),
+        definition,
+    };
+}
+function publicSpecifierAddress(specifier) {
+    if (specifier.trim() !== specifier ||
+        specifier.startsWith(".") ||
+        specifier.startsWith("/") ||
+        specifier.startsWith("file:")) {
+        throw new Error(`内容成员必须使用公开包specifier：${specifier}`);
+    }
+    const parts = specifier.split("/");
+    const packageLength = specifier.startsWith("@") ? 2 : 1;
+    if (parts.length < packageLength ||
+        parts.slice(0, packageLength).some((part) => part.length === 0)) {
+        throw new Error(`内容成员的公开包specifier无效：${specifier}`);
+    }
+    const packageName = parts.slice(0, packageLength).join("/");
+    const exportSegments = parts.slice(packageLength);
+    return {
+        packageName,
+        exportPath: exportSegments.length === 0 ? "." : `./${exportSegments.join("/")}`,
+    };
+}
+function resolveLocalURL(resolve, specifier, label) {
+    let resolved;
+    try {
+        resolved = resolve(specifier);
+    }
+    catch (error) {
+        throw new Error(`${label}解析失败：${specifier}：${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    let url;
+    try {
+        url = new URL(resolved);
+    }
+    catch {
+        throw new Error(`${label}解析结果不是绝对URL：${specifier}`);
+    }
+    if (url.protocol !== "file:") {
+        throw new Error(`${label}必须解析为本地文件URL：${specifier}`);
+    }
+    return url.href;
+}
+function assertNativeManifest(value, specifier) {
+    if (!isRecord(value) ||
+        typeof value.name !== "string" ||
+        !isRecord(value.exports)) {
+        throw new Error(`内容${specifier}的公开原生清单缺少包名或exports`);
+    }
+    return value;
+}
+function isPreparedReference(value) {
+    return (isRecord(value) &&
+        typeof value.alias === "string" &&
+        (value.instance === "shared" || value.instance === "independent") &&
+        isRecord(value.manifest));
+}
+function requireAlias(value, specifier) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`内容${specifier}的公开定义缺少有效别名`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@ykdz/template-generator/dist/index.d.ts

@@ -0,0 +1,82 @@
+import { type ContentSelector, type LoadedContentMember } from "@ykdz/template-core/content-identity";
+import { type PackageContribution } from "@ykdz/template-core/package-contribution";
+import type { PresetDefinition, PresetProjectOptions, PresetReference } from "@ykdz/template-core/preset-definition";
+import { type PackageDefinition, type PackageDefinitionId, type ProjectBlueprint } from "@ykdz/template-core/project-blueprint";
+import { type ProjectProjectionAction, type ProjectProjectionConflict } from "@ykdz/template-core/project-projection";
+import type { GenerationRecord, GeneratorContent, GeneratorSelectionRoot, PackageCreationInput, WorkspaceStrategyFailureDiagnostic, WorkspaceProjection, WorkspaceStrategy } from "@ykdz/template-core/workspace-strategy";
+export type { GenerationRecord } from "@ykdz/template-core/workspace-strategy";
+export { generationRecordSchema } from "@ykdz/template-core/workspace-strategy";
+export type GeneratorResult<CreationInput extends PackageCreationInput = PackageCreationInput, OwnerFacts = unknown> = {
+    readonly status: "success";
+    readonly dryRun: boolean;
+    readonly blueprint: ProjectBlueprint;
+    readonly generationRecord: GenerationRecord<CreationInput>;
+    /** 无动作幂等结果没有新的投影。 */
+    readonly projection: WorkspaceProjection<OwnerFacts> | null;
+    readonly actions: readonly ProjectProjectionAction[];
+} | {
+    readonly status: "input-invalid";
+    readonly issues: readonly {
+        readonly code: string;
+    }[];
+} | {
+    readonly status: "conflict";
+    readonly dryRun: boolean;
+    readonly reason: string;
+    readonly conflicts: readonly ProjectProjectionConflict[];
+    /** 同次目标身份比较得到的既有与请求包身份。 */
+    readonly identityConflict?: {
+        readonly existing: GeneratorPackageIdentity;
+        readonly requested: GeneratorPackageIdentity;
+    };
+    /** 所属 workspace 产生的用户冲突事实，由其公开 owner 解释。 */
+    readonly ownerConflict?: {
+        readonly code: string;
+        readonly facts: unknown;
+    };
+    readonly actions: readonly [];
+} | {
+    readonly status: "operation-failure";
+    readonly phase: "metadata" | "planning" | "render" | "reconciliation";
+    readonly error: {
+        readonly message: string;
+        readonly diagnostic?: WorkspaceStrategyFailureDiagnostic;
+    };
+};
+export type GeneratorPackageIdentity = Pick<PackageDefinition, "name" | "path" | "role">;
+export type Generator<Input, CreationInput extends PackageCreationInput = PackageCreationInput, Reference extends PresetReference = PresetReference, NodeLayout = unknown, Context = unknown, Contribution extends PackageContribution = PackageContribution, PresetProjectContribution = unknown, OwnerFacts = unknown> = {
+    init(options: {
+        readonly targetRoot: string;
+        readonly selection: {
+            readonly roots: readonly GeneratorSelectionInput<Reference, CreationInput, NodeLayout, Context, Contribution, PresetProjectContribution>[];
+        };
+        readonly strategyInput: Input;
+        readonly dryRun?: boolean;
+    }): Promise<GeneratorResult<CreationInput, OwnerFacts>>;
+    configure(options: {
+        readonly repositoryRoot: string;
+        readonly packageDefinitionId: PackageDefinitionId;
+        readonly configuration: unknown;
+        readonly dryRun?: boolean;
+    }): Promise<GeneratorResult<CreationInput, OwnerFacts>>;
+    add(options: {
+        readonly repositoryRoot: string;
+        readonly creationInput?: CreationInput;
+        readonly configuration?: unknown;
+        readonly dryRun?: boolean;
+    } & ({
+        readonly contentIdentity: ContentSelector;
+    } | {
+        readonly preset: ContentSelector | PresetDefinition<Reference, NodeLayout, CreationInput, PresetProjectOptions<Context, Contribution>, PresetProjectContribution>;
+    })): Promise<GeneratorResult<CreationInput, OwnerFacts>>;
+};
+type GeneratorSelectionInput<Reference extends PresetReference, CreationInput extends PackageCreationInput, NodeLayout, Context, Contribution, PresetProjectContribution> = GeneratorSelectionRoot<CreationInput, NodeLayout> | {
+    readonly preset: ContentSelector | PresetDefinition<Reference, NodeLayout, CreationInput, PresetProjectOptions<Context, Contribution>, PresetProjectContribution>;
+    readonly creationInput?: CreationInput;
+    readonly configuration?: unknown;
+};
+export declare function parseGenerationRecord<CreationInput extends PackageCreationInput = PackageCreationInput>(value: unknown): GenerationRecord<CreationInput>;
+export declare function createGenerator<Context, Input, State, Contribution extends PackageContribution, CreationInput extends PackageCreationInput, Content extends GeneratorContent<Context, Contribution, CreationInput>, NodeLayout, PresetProjectContribution = unknown, OwnerFacts = unknown>(options: {
+    readonly content: readonly LoadedContentMember[];
+    readonly strategy: WorkspaceStrategy<Context, Input, State, Contribution, CreationInput, Content, NodeLayout, PresetProjectContribution, OwnerFacts>;
+}): Generator<Input, CreationInput, Content["definition"] & PresetReference, NodeLayout, Context, Contribution, PresetProjectContribution, OwnerFacts>;