@wp-typia/project-tools 0.24.3 → 0.24.5

package/dist/runtime/workspace/workspace-project.js

@@ -0,0 +1,142 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parsePackageManagerField, } from "../shared/package-managers.js";
+import { readJsonFileSync } from "../shared/json-utils.js";
+export const WORKSPACE_TEMPLATE_PACKAGE = "@wp-typia/create-workspace-template";
+function hasNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/**
+ * Parse a workspace package manifest from a project directory or `package.json` path.
+ *
+ * @param projectDirOrManifestPath Absolute or relative project directory, or a direct
+ * path to `package.json`.
+ * @returns The parsed workspace package manifest.
+ * @throws {Error} When the manifest cannot be parsed.
+ */
+export function parseWorkspacePackageJson(projectDirOrManifestPath) {
+    const packageJsonPath = path.basename(projectDirOrManifestPath) === "package.json"
+        ? projectDirOrManifestPath
+        : path.join(projectDirOrManifestPath, "package.json");
+    return readJsonFileSync(packageJsonPath, {
+        context: "workspace package manifest",
+    });
+}
+function getWorkspaceMetadataIssues(packageJson) {
+    if (!packageJson.wpTypia) {
+        return [];
+    }
+    const issues = [];
+    if (packageJson.wpTypia.projectType !== "workspace") {
+        issues.push('wpTypia.projectType must be "workspace"');
+    }
+    if (packageJson.wpTypia.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
+        issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
+    }
+    if (!hasNonEmptyString(packageJson.wpTypia.namespace)) {
+        issues.push("wpTypia.namespace must be a non-empty string");
+    }
+    if (!hasNonEmptyString(packageJson.wpTypia.textDomain)) {
+        issues.push("wpTypia.textDomain must be a non-empty string");
+    }
+    if (!hasNonEmptyString(packageJson.wpTypia.phpPrefix)) {
+        issues.push("wpTypia.phpPrefix must be a non-empty string");
+    }
+    return issues;
+}
+/**
+ * Explain why a nearby wp-typia workspace cannot be resolved from `startDir`.
+ *
+ * @param startDir Directory to begin walking upward from.
+ * @returns A human-readable validation error when a candidate workspace package
+ * manifest is found but its `wpTypia` metadata is invalid, or `null` when no
+ * invalid workspace candidate is discovered.
+ * @throws {Error} When a discovered `package.json` cannot be parsed.
+ */
+export function getInvalidWorkspaceProjectReason(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = parseWorkspacePackageJson(packageJsonPath);
+            const issues = getWorkspaceMetadataIssues(packageJson);
+            if (issues.length > 0) {
+                return `Invalid wp-typia workspace metadata at ${packageJsonPath}: ${issues.join("; ")}`;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    return null;
+}
+/**
+ * Parse a package-manager identifier from a `packageManager` field.
+ *
+ * @param packageManagerField Raw package-manager field such as `bun@1.3.11`.
+ * @returns A normalized `PackageManagerId`, defaulting to `"npm"` when the
+ * field is missing or unsupported.
+ */
+export function parseWorkspacePackageManagerId(packageManagerField) {
+    return parsePackageManagerField(packageManagerField) ?? "npm";
+}
+/**
+ * Try to resolve the nearest official wp-typia workspace from `startDir`.
+ *
+ * @param startDir Directory to begin walking upward from.
+ * @returns The resolved `WorkspaceProject`, or `null` when no
+ * `WORKSPACE_TEMPLATE_PACKAGE` workspace is found.
+ * @throws {Error} When a discovered `package.json` cannot be parsed.
+ */
+export function tryResolveWorkspaceProject(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = parseWorkspacePackageJson(packageJsonPath);
+            if (packageJson.wpTypia?.projectType === "workspace" &&
+                packageJson.wpTypia?.templatePackage === WORKSPACE_TEMPLATE_PACKAGE &&
+                hasNonEmptyString(packageJson.wpTypia.namespace) &&
+                hasNonEmptyString(packageJson.wpTypia.textDomain) &&
+                hasNonEmptyString(packageJson.wpTypia.phpPrefix)) {
+                return {
+                    author: typeof packageJson.author === "string" ? packageJson.author : "Your Name",
+                    packageManager: parseWorkspacePackageManagerId(packageJson.packageManager),
+                    packageName: typeof packageJson.name === "string"
+                        ? packageJson.name
+                        : path.basename(currentDir),
+                    projectDir: currentDir,
+                    workspace: {
+                        namespace: packageJson.wpTypia.namespace,
+                        phpPrefix: packageJson.wpTypia.phpPrefix,
+                        projectType: "workspace",
+                        templatePackage: WORKSPACE_TEMPLATE_PACKAGE,
+                        textDomain: packageJson.wpTypia.textDomain,
+                    },
+                };
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    return null;
+}
+/**
+ * Resolve the nearest official wp-typia workspace from `startDir`.
+ *
+ * @param startDir Directory to begin walking upward from.
+ * @returns The resolved `WorkspaceProject`.
+ * @throws {Error} When no `WORKSPACE_TEMPLATE_PACKAGE` workspace can be found.
+ */
+export function resolveWorkspaceProject(startDir) {
+    const workspace = tryResolveWorkspaceProject(startDir);
+    if (workspace) {
+        return workspace;
+    }
+    throw new Error(`This command must run inside an official wp-typia workspace. Create one with \`wp-typia create my-plugin --template workspace\` first (the short alias for \`${WORKSPACE_TEMPLATE_PACKAGE}\`).`);
+}

package/dist/runtime/workspace-inventory-mutations.d.ts

@@ -1,24 +1 @@
-import type { WorkspaceInventoryUpdateOptions } from "./workspace-inventory-types.js";
-/**
- * Update `scripts/block-config.ts` source text with additional inventory entries.
- *
- * Missing inventory sections for variations, patterns, binding sources, REST
- * resources, workflow abilities, AI features, editor plugins, block styles, and
- * block transforms are created
- * automatically before new entries are appended at their marker comments.
- * When provided, `transformSource` runs before any entries are inserted.
- *
- * @param source Existing `scripts/block-config.ts` source.
- * @param options Entry lists plus an optional source transformer.
- * @returns Updated source text with all requested inventory entries appended.
- */
-export declare function updateWorkspaceInventorySource(source: string, options?: WorkspaceInventoryUpdateOptions): string;
-/**
- * Append new entries to the canonical workspace inventory file on disk.
- *
- * @param projectDir Workspace root directory.
- * @param options Entry lists and optional source transform passed through to
- * `updateWorkspaceInventorySource`.
- * @returns Resolves once `scripts/block-config.ts` has been updated if needed.
- */
-export declare function appendWorkspaceInventoryEntries(projectDir: string, options: Parameters<typeof updateWorkspaceInventorySource>[1]): Promise<void>;
+export * from "./workspace/workspace-inventory-mutations.js";

package/dist/runtime/workspace-inventory-mutations.js

@@ -1,195 +1 @@
-import path from "node:path";
-import { readFile, writeFile } from "node:fs/promises";
-import { escapeRegex } from "./php-utils.js";
-import { BLOCK_INVENTORY_SECTION, INVENTORY_SECTIONS, } from "./workspace-inventory-section-descriptors.js";
-import { WORKSPACE_COMPATIBILITY_CONFIG_FIELD } from "./workspace-inventory-templates.js";
-function ensureWorkspaceInventorySections(source) {
-    let nextSource = source.trimEnd();
-    for (const section of INVENTORY_SECTIONS) {
-        if (section.interface &&
-            !hasExportedTypeDeclaration(nextSource, section.interface.name)) {
-            nextSource += section.interface.section;
-        }
-        if (section.value && !hasExportedConst(nextSource, section.value.name)) {
-            nextSource += section.value.section;
-        }
-    }
-    return `${nextSource}\n`;
-}
-function hasExportedTypeDeclaration(source, interfaceName) {
-    return new RegExp(`export\\s+(?:interface|type)\\s+${escapeRegex(interfaceName)}\\b`, "u").test(source);
-}
-function hasExportedConst(source, constName) {
-    return new RegExp(`export\\s+const\\s+${escapeRegex(constName)}\\b`, "u").test(source);
-}
-function appendEntriesAtMarker(source, marker, entries) {
-    if (entries.length === 0) {
-        return source;
-    }
-    if (!source.includes(marker)) {
-        throw new Error(`Workspace inventory marker "${marker}" is missing in scripts/block-config.ts.`);
-    }
-    const replacement = `${entries.join("\n")}\n${marker}`;
-    return source.replace(marker, () => replacement);
-}
-function appendInventorySectionEntries(source, options) {
-    let nextSource = source;
-    for (const section of [BLOCK_INVENTORY_SECTION, ...INVENTORY_SECTIONS]) {
-        if (!section.append) {
-            continue;
-        }
-        nextSource = appendEntriesAtMarker(nextSource, section.append.marker, options[section.append.optionKey] ?? []);
-    }
-    return nextSource;
-}
-function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
-    const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
-    return source.replace(interfacePattern, (match, start, body, end) => {
-        if (new RegExp(`^[ \t]*${escapeRegex(fieldName)}\\??:`, "mu").test(body)) {
-            return match;
-        }
-        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
-        const formattedFieldSource = `${fieldSource
-            .replace(/\r?\n$/u, "")
-            .split("\n")
-            .join(lineEnding)}${lineEnding}`;
-        const memberPattern = /^[ \t]*([A-Za-z_$][\w$]*)\??:/gmu;
-        for (const member of body.matchAll(memberPattern)) {
-            const memberIndex = member.index;
-            const memberName = member[1];
-            if (memberIndex === undefined || !memberName) {
-                continue;
-            }
-            if (memberName.localeCompare(fieldName) > 0) {
-                return `${start}${body.slice(0, memberIndex)}${formattedFieldSource}${body.slice(memberIndex)}${end}`;
-            }
-        }
-        return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
-    });
-}
-function upsertInterfaceField(source, interfaceName, fieldName, fieldSource) {
-    const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
-    return source.replace(interfacePattern, (match, start, body, end) => {
-        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
-        const formattedFieldSource = `${fieldSource
-            .replace(/\r?\n$/u, "")
-            .split("\n")
-            .join(lineEnding)}${lineEnding}`;
-        const existingFieldPattern = new RegExp(`(^[ \\t]*${escapeRegex(fieldName)}\\??:\\s*[^;\\r\\n]+;?\\r?\\n?)`, "mu");
-        const existingFieldMatch = existingFieldPattern.exec(body);
-        if (existingFieldMatch?.[0]) {
-            if (existingFieldMatch[0].trim() === fieldSource.trim()) {
-                return match;
-            }
-            return `${start}${body.slice(0, existingFieldMatch.index)}${formattedFieldSource}${body.slice(existingFieldMatch.index + existingFieldMatch[0].length)}${end}`;
-        }
-        const memberPattern = /^[ \t]*([A-Za-z_$][\w$]*)\??:/gmu;
-        for (const member of body.matchAll(memberPattern)) {
-            const memberIndex = member.index;
-            const memberName = member[1];
-            if (memberIndex === undefined || !memberName) {
-                continue;
-            }
-            if (memberName.localeCompare(fieldName) > 0) {
-                return `${start}${body.slice(0, memberIndex)}${formattedFieldSource}${body.slice(memberIndex)}${end}`;
-            }
-        }
-        return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
-    });
-}
-function normalizeInterfaceFieldBlock(source, interfaceName, fieldName, fieldSource, requiredFragments) {
-    const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
-    return source.replace(interfacePattern, (match, start, body, end) => {
-        const fieldPattern = new RegExp(`(^([ \\t]*)${escapeRegex(fieldName)}\\??:\\s*\\{[ \\t]*\\r?\\n)([\\s\\S]*?)(^\\2\\};\\r?\\n?)`, "mu");
-        const fieldMatch = fieldPattern.exec(body);
-        if (!fieldMatch) {
-            return match;
-        }
-        const existingFieldSource = fieldMatch[0];
-        if (requiredFragments.every((fragment) => existingFieldSource.includes(fragment))) {
-            return match;
-        }
-        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
-        const formattedFieldSource = `${fieldSource
-            .replace(/\r?\n$/u, "")
-            .split("\n")
-            .join(lineEnding)}${lineEnding}`;
-        return `${start}${body.slice(0, fieldMatch.index)}${formattedFieldSource}${body.slice(fieldMatch.index + existingFieldSource.length)}${end}`;
-    });
-}
-/**
- * Update `scripts/block-config.ts` source text with additional inventory entries.
- *
- * Missing inventory sections for variations, patterns, binding sources, REST
- * resources, workflow abilities, AI features, editor plugins, block styles, and
- * block transforms are created
- * automatically before new entries are appended at their marker comments.
- * When provided, `transformSource` runs before any entries are inserted.
- *
- * @param source Existing `scripts/block-config.ts` source.
- * @param options Entry lists plus an optional source transformer.
- * @returns Updated source text with all requested inventory entries appended.
- */
-export function updateWorkspaceInventorySource(source, options = {}) {
-    let nextSource = ensureWorkspaceInventorySections(source);
-    if (options.transformSource) {
-        nextSource = options.transformSource(nextSource);
-    }
-    nextSource = appendInventorySectionEntries(nextSource, options);
-    for (const [fieldName, fieldSource] of [
-        ["contentFile", "\tcontentFile?: string;"],
-        ["file", "\tfile?: string;"],
-        ["scope", "\tscope?: 'full' | 'section';"],
-        ["sectionRole", "\tsectionRole?: string;"],
-        ["tags", "\ttags?: string[];"],
-        ["thumbnailUrl", "\tthumbnailUrl?: string;"],
-        ["title", "\ttitle?: string;"],
-    ]) {
-        nextSource = upsertInterfaceField(nextSource, "WorkspacePatternConfig", fieldName, fieldSource);
-    }
-    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "attribute", "\tattribute?: string;");
-    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "block", "\tblock?: string;");
-    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "metaPath", "\tmetaPath?: string;");
-    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "postMeta", "\tpostMeta?: string;");
-    nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
-    nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
-    nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
-    nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
-    for (const [fieldName, fieldSource] of [
-        ["auth", "\tauth?: 'authenticated' | 'public' | 'public-write-protected';"],
-        ["bodyTypeName", "\tbodyTypeName?: string;"],
-        ["controllerClass", "\tcontrollerClass?: string;"],
-        ["controllerExtends", "\tcontrollerExtends?: string;"],
-        ["dataFile", "\tdataFile?: string;"],
-        ["method", "\tmethod?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';"],
-        ["mode", "\tmode?: 'generated' | 'manual';"],
-        ["pathPattern", "\tpathPattern?: string;"],
-        ["permissionCallback", "\tpermissionCallback?: string;"],
-        ["phpFile", "\tphpFile?: string;"],
-        ["queryTypeName", "\tqueryTypeName?: string;"],
-        ["responseTypeName", "\tresponseTypeName?: string;"],
-        ["routePattern", "\troutePattern?: string;"],
-        ["secretFieldName", "\tsecretFieldName?: string;"],
-        ["secretPreserveOnEmpty", "\tsecretPreserveOnEmpty?: boolean;"],
-        ["secretStateFieldName", "\tsecretStateFieldName?: string;"],
-    ]) {
-        nextSource = upsertInterfaceField(nextSource, "WorkspaceRestResourceConfig", fieldName, fieldSource);
-    }
-    return nextSource;
-}
-/**
- * Append new entries to the canonical workspace inventory file on disk.
- *
- * @param projectDir Workspace root directory.
- * @param options Entry lists and optional source transform passed through to
- * `updateWorkspaceInventorySource`.
- * @returns Resolves once `scripts/block-config.ts` has been updated if needed.
- */
-export async function appendWorkspaceInventoryEntries(projectDir, options) {
-    const blockConfigPath = path.join(projectDir, "scripts", "block-config.ts");
-    const source = await readFile(blockConfigPath, "utf8");
-    const nextSource = updateWorkspaceInventorySource(source, options);
-    if (nextSource !== source) {
-        await writeFile(blockConfigPath, nextSource, "utf8");
-    }
-}
+export * from "./workspace/workspace-inventory-mutations.js";

package/dist/runtime/workspace-inventory-parser-entries.d.ts

@@ -1,17 +1 @@
-import ts from "typescript";
-import { type InventorySectionDescriptor } from "./workspace-inventory-parser-validation.js";
-/**
- * Parse one descriptor-backed inventory section from a TypeScript source file.
- *
- * The generic `T` is the typed entry shape returned in `entries`. The
- * `descriptor` supplies the exported array name, parser field metadata, and
- * whether the section is required; this helper uses `findExportedArrayLiteral`
- * and `parseInventoryEntries` to guarantee object-literal entries and literal
- * field values. It returns parsed entries plus a `found` flag, and throws when
- * required exports are missing, descriptors cannot resolve an export name, or
- * exported values are not array literals.
- */
-export declare function parseInventorySection<T extends object>(sourceFile: ts.SourceFile, descriptor: InventorySectionDescriptor): {
-    entries: T[];
-    found: boolean;
-};
+export * from "./workspace/workspace-inventory-parser-entries.js";

package/dist/runtime/workspace-inventory-parser-entries.js

@@ -1,157 +1 @@
-import ts from "typescript";
-import { getPropertyNameText } from "./ts-property-names.js";
-import { assertParsedInventoryEntry, } from "./workspace-inventory-parser-validation.js";
-function findExportedArrayLiteral(sourceFile, exportName) {
-    for (const statement of sourceFile.statements) {
-        if (!ts.isVariableStatement(statement)) {
-            continue;
-        }
-        if (!statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-            continue;
-        }
-        for (const declaration of statement.declarationList.declarations) {
-            if (!ts.isIdentifier(declaration.name) ||
-                declaration.name.text !== exportName) {
-                continue;
-            }
-            if (declaration.initializer &&
-                ts.isArrayLiteralExpression(declaration.initializer)) {
-                return {
-                    array: declaration.initializer,
-                    found: true,
-                };
-            }
-            return {
-                array: null,
-                found: true,
-            };
-        }
-    }
-    return {
-        array: null,
-        found: false,
-    };
-}
-function getOptionalStringProperty(entryName, elementIndex, objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
-        }
-        const propertyName = getPropertyNameText(property.name);
-        if (propertyName !== key) {
-            continue;
-        }
-        if (ts.isStringLiteralLike(property.initializer)) {
-            return property.initializer.text;
-        }
-        throw new Error(`${entryName}[${elementIndex}] must use a string literal for "${key}" in scripts/block-config.ts.`);
-    }
-    return undefined;
-}
-function getOptionalStringArrayProperty(entryName, elementIndex, objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
-        }
-        const propertyName = getPropertyNameText(property.name);
-        if (propertyName !== key) {
-            continue;
-        }
-        if (!ts.isArrayLiteralExpression(property.initializer)) {
-            throw new Error(`${entryName}[${elementIndex}] must use an array literal for "${key}" in scripts/block-config.ts.`);
-        }
-        return property.initializer.elements.map((element, itemIndex) => {
-            if (!ts.isStringLiteralLike(element)) {
-                throw new Error(`${entryName}[${elementIndex}].${key}[${itemIndex}] must use a string literal in scripts/block-config.ts.`);
-            }
-            return element.text;
-        });
-    }
-    return undefined;
-}
-function getOptionalBooleanProperty(entryName, elementIndex, objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
-        }
-        const propertyName = getPropertyNameText(property.name);
-        if (propertyName !== key) {
-            continue;
-        }
-        if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-            return true;
-        }
-        if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) {
-            return false;
-        }
-        throw new Error(`${entryName}[${elementIndex}] must use a boolean literal for "${key}" in scripts/block-config.ts.`);
-    }
-    return undefined;
-}
-function parseInventoryEntries(arrayLiteral, descriptor) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`${descriptor.entryName}[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        const entry = {};
-        for (const field of descriptor.fields) {
-            const kind = field.kind ?? "string";
-            const value = kind === "stringArray"
-                ? getOptionalStringArrayProperty(descriptor.entryName, elementIndex, element, field.key)
-                : kind === "boolean"
-                    ? getOptionalBooleanProperty(descriptor.entryName, elementIndex, element, field.key)
-                    : getOptionalStringProperty(descriptor.entryName, elementIndex, element, field.key);
-            field.validate?.(value, {
-                elementIndex,
-                entryName: descriptor.entryName,
-                key: field.key,
-            });
-            entry[field.key] = value;
-        }
-        assertParsedInventoryEntry(entry, descriptor, elementIndex);
-        return entry;
-    });
-}
-/**
- * Parse one descriptor-backed inventory section from a TypeScript source file.
- *
- * The generic `T` is the typed entry shape returned in `entries`. The
- * `descriptor` supplies the exported array name, parser field metadata, and
- * whether the section is required; this helper uses `findExportedArrayLiteral`
- * and `parseInventoryEntries` to guarantee object-literal entries and literal
- * field values. It returns parsed entries plus a `found` flag, and throws when
- * required exports are missing, descriptors cannot resolve an export name, or
- * exported values are not array literals.
- */
-export function parseInventorySection(sourceFile, descriptor) {
-    if (!descriptor.parse) {
-        return {
-            entries: [],
-            found: false,
-        };
-    }
-    const exportName = descriptor.parse.exportName ?? descriptor.value?.name;
-    if (!exportName) {
-        throw new Error("Inventory parser descriptor is missing an export name.");
-    }
-    const exportedArray = findExportedArrayLiteral(sourceFile, exportName);
-    if (!exportedArray.found) {
-        if (descriptor.parse.required) {
-            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
-        }
-        return {
-            entries: [],
-            found: false,
-        };
-    }
-    if (!exportedArray.array) {
-        if (descriptor.parse.required) {
-            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
-        }
-        throw new Error(`scripts/block-config.ts must export ${exportName} as an array literal.`);
-    }
-    return {
-        entries: parseInventoryEntries(exportedArray.array, descriptor.parse.entry),
-        found: true,
-    };
-}
+export * from "./workspace/workspace-inventory-parser-entries.js";

package/dist/runtime/workspace-inventory-parser-validation.d.ts

@@ -1,104 +1 @@
-import type { WorkspaceInventoryAppendOptionKey, WorkspaceInventoryEntriesKey, WorkspaceInventorySectionFlagKey } from "./workspace-inventory-types.js";
-/**
- * Literal value shape accepted by descriptor-driven inventory entry fields.
- */
-export type InventoryEntryFieldValue = string | string[] | boolean | undefined;
-/**
- * Context passed to custom field validators while parsing one inventory entry.
- */
-export type InventoryEntryFieldValidationContext = {
-    elementIndex: number;
-    entryName: string;
-    key: string;
-};
-type InventoryEntryFieldDescriptor = {
-    key: string;
-    kind?: "boolean" | "string" | "stringArray";
-    required?: boolean;
-    validate?: (value: InventoryEntryFieldValue, context: InventoryEntryFieldValidationContext) => void;
-};
-/**
- * Runtime parser contract for one exported inventory array.
- *
- * `entryName` is used in diagnostics and `fields` defines the literal values,
- * required flags, and custom validators accepted for each object entry.
- */
-export type InventoryEntryParserDescriptor = {
-    entryName: string;
-    fields: readonly InventoryEntryFieldDescriptor[];
-};
-type RequiredInventoryEntryKey<T extends object> = Extract<{
-    [Key in keyof T]-?: undefined extends T[Key] ? never : Key;
-}[keyof T], string>;
-type TypedInventoryEntryFieldDescriptor<T extends object, TKey extends Extract<keyof T, string> = Extract<keyof T, string>> = TKey extends Extract<keyof T, string> ? Omit<InventoryEntryFieldDescriptor, "key" | "required"> & {
-    key: TKey;
-} & (TKey extends RequiredInventoryEntryKey<T> ? {
-    required: true;
-} : {
-    required?: boolean;
-}) : never;
-type RequiredInventoryEntryFieldDescriptor<T extends object> = Omit<InventoryEntryFieldDescriptor, "key" | "required"> & {
-    key: RequiredInventoryEntryKey<T>;
-    required: true;
-};
-type MissingRequiredInventoryEntryKeys<T extends object, TFields extends readonly TypedInventoryEntryFieldDescriptor<T>[]> = Exclude<RequiredInventoryEntryKey<T>, TFields[number]["key"]>;
-type RequiredInventoryEntryFieldsPresent<T extends object, TFields extends readonly TypedInventoryEntryFieldDescriptor<T>[]> = MissingRequiredInventoryEntryKeys<T, TFields> extends never ? unknown : {
-    missingRequiredInventoryEntryFields: MissingRequiredInventoryEntryKeys<T, TFields>;
-};
-type RequiredInventoryEntryFieldsMarkedRequired<T extends object, TFields extends readonly TypedInventoryEntryFieldDescriptor<T>[]> = Extract<TFields[number], {
-    key: RequiredInventoryEntryKey<T>;
-}> extends RequiredInventoryEntryFieldDescriptor<T> ? unknown : {
-    requiredInventoryEntryFieldsMustSetRequiredTrue: RequiredInventoryEntryKey<T>;
-};
-/**
- * Shared descriptor contract for generated workspace inventory sections.
- *
- * Callers rely on `append` markers when inserting generated entries, `parse`
- * metadata when reading exported arrays, and `interface`/`value` sections when
- * repairing older `scripts/block-config.ts` files.
- */
-export type InventorySectionDescriptor = {
-    /** Optional marker metadata used when appending generated entries. */
-    append?: {
-        marker: string;
-        optionKey: WorkspaceInventoryAppendOptionKey;
-    };
-    /** Optional exported interface that backs the inventory section entries. */
-    interface?: {
-        name: string;
-        section: string;
-    };
-    /** Optional parser metadata for descriptor-driven inventory reads. */
-    parse?: {
-        entriesKey: WorkspaceInventoryEntriesKey;
-        entry: InventoryEntryParserDescriptor;
-        exportName?: string;
-        hasSectionKey?: WorkspaceInventorySectionFlagKey;
-        required?: boolean;
-    };
-    /** Optional exported const array that stores the inventory section entries. */
-    value?: {
-        name: string;
-        section: string;
-    };
-};
-/**
- * Define a typed inventory entry parser while enforcing required fields at
- * compile time.
- *
- * The returned descriptor is consumed by `parseInventorySection` to extract
- * literal field values and run runtime validators.
- */
-export declare function defineInventoryEntryParser<T extends object>(): <const TFields extends readonly TypedInventoryEntryFieldDescriptor<T>[]>(descriptor: {
-    entryName: string;
-    fields: TFields;
-} & RequiredInventoryEntryFieldsPresent<T, TFields> & RequiredInventoryEntryFieldsMarkedRequired<T, TFields>) => InventoryEntryParserDescriptor;
-/**
- * Assert that a parsed inventory entry contains every required descriptor
- * field.
- *
- * Missing `undefined` values and empty strings throw with diagnostics tied to
- * the original exported inventory array name and element index.
- */
-export declare function assertParsedInventoryEntry<T extends object>(entry: Record<string, InventoryEntryFieldValue>, descriptor: InventoryEntryParserDescriptor, elementIndex: number): asserts entry is Record<string, InventoryEntryFieldValue> & T;
-export {};
+export * from "./workspace/workspace-inventory-parser-validation.js";