@wp-typia/block-runtime 0.4.2 → 0.4.4

package/dist/blocks.d.ts

@@ -34,6 +34,19 @@ export interface TypiaWebpackConfigOptions {
     path: {
         join(...paths: string[]): string;
     };
+    projectRoot?: string;
+}
+export interface TypiaWebpackPluginLoaderOptions {
+    importTypiaWebpackPlugin: () => Promise<{
+        default: () => unknown;
+    }>;
+    projectRoot?: string;
+}
+interface TypiaWebpackVersionMatrix {
+    "@typia/unplugin": string | null;
+    "@wordpress/scripts": string | null;
+    typia: string | null;
+    webpack: string | null;
 }
 type OverrideProperties<TBase, TOverride> = Omit<TBase, keyof TOverride> & TOverride;
 type ScaffoldSupportDefaultControls<TFeature extends string> = Readonly<Partial<Record<TFeature, boolean>> & Record<string, boolean | undefined>>;
@@ -169,8 +182,12 @@ export interface BuildScaffoldBlockRegistrationResult<TSettings extends object>
     name: string;
     settings: TSettings;
 }
+export declare function assertTypiaWebpackCompatibility({ projectRoot, }?: {
+    projectRoot?: string;
+}): Promise<TypiaWebpackVersionMatrix>;
+export declare function loadCompatibleTypiaWebpackPlugin({ importTypiaWebpackPlugin, projectRoot, }: TypiaWebpackPluginLoaderOptions): Promise<() => unknown>;
 export declare function buildScaffoldBlockRegistration<TSettings extends object>(metadata: ScaffoldBlockMetadata, overrides: Partial<TSettings> & Record<string, unknown>): BuildScaffoldBlockRegistrationResult<TSettings>;
-export declare function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset, moduleEntriesMode, nonModuleEntriesMode, path, }: TypiaWebpackConfigOptions): Promise<{
+export declare function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset, moduleEntriesMode, nonModuleEntriesMode, path, projectRoot, }: TypiaWebpackConfigOptions): Promise<{
     entry: () => Promise<Record<string, unknown>>;
     plugins: unknown[];
 } | {

package/dist/blocks.js

@@ -15,6 +15,96 @@ function isModuleConfig(config) {
         config !== null &&
         config.output?.module === true);
 }
+function parseMajorVersion(version) {
+    if (!version) {
+        return null;
+    }
+    const match = /^(\d+)/u.exec(version);
+    return match ? Number.parseInt(match[1], 10) : null;
+}
+function readPackageVersion(readFileSync, packageJsonPath) {
+    try {
+        return JSON.parse(readFileSync(packageJsonPath, "utf8")).version;
+    }
+    catch {
+        return null;
+    }
+}
+async function loadNodeRuntimeHelpers() {
+    const importNodeModule = Function("specifier", "return import(specifier);");
+    const [fsModule, moduleBuiltin, pathBuiltin] = (await Promise.all([
+        importNodeModule("node:fs"),
+        importNodeModule("node:module"),
+        importNodeModule("node:path"),
+    ]));
+    return {
+        createRequire: moduleBuiltin.createRequire,
+        pathModule: pathBuiltin,
+        readFileSync: fsModule.readFileSync,
+    };
+}
+function resolveInstalledPackageVersion(readFileSync, requireFromProject, packageName) {
+    try {
+        return readPackageVersion(readFileSync, requireFromProject.resolve(`${packageName}/package.json`));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveWebpackVersion(readFileSync, requireFromProject, createRequire) {
+    try {
+        const wordpressScriptsPackageJsonPath = requireFromProject.resolve("@wordpress/scripts/package.json");
+        const requireFromWordPressScripts = createRequire(wordpressScriptsPackageJsonPath);
+        const bundledWebpackVersion = resolveInstalledPackageVersion(readFileSync, requireFromWordPressScripts, "webpack");
+        if (bundledWebpackVersion) {
+            return bundledWebpackVersion;
+        }
+    }
+    catch {
+        // fall through to the project-level webpack resolution below
+    }
+    return resolveInstalledPackageVersion(readFileSync, requireFromProject, "webpack");
+}
+async function getTypiaWebpackVersionMatrix(projectRoot = process.cwd()) {
+    const { createRequire, pathModule, readFileSync } = await loadNodeRuntimeHelpers();
+    const packageJsonPath = pathModule.resolve(projectRoot, "package.json");
+    const requireFromProject = createRequire(packageJsonPath);
+    return {
+        "@typia/unplugin": resolveInstalledPackageVersion(readFileSync, requireFromProject, "@typia/unplugin"),
+        "@wordpress/scripts": resolveInstalledPackageVersion(readFileSync, requireFromProject, "@wordpress/scripts"),
+        typia: resolveInstalledPackageVersion(readFileSync, requireFromProject, "typia"),
+        webpack: resolveWebpackVersion(readFileSync, requireFromProject, createRequire),
+    };
+}
+function formatInstalledMatrix(versionMatrix) {
+    return [
+        `typia=${versionMatrix.typia ?? "missing"}`,
+        `@typia/unplugin=${versionMatrix["@typia/unplugin"] ?? "missing"}`,
+        `@wordpress/scripts=${versionMatrix["@wordpress/scripts"] ?? "missing"}`,
+        `webpack=${versionMatrix.webpack ?? "missing"}`,
+    ].join(", ");
+}
+export async function assertTypiaWebpackCompatibility({ projectRoot = process.cwd(), } = {}) {
+    const versionMatrix = await getTypiaWebpackVersionMatrix(projectRoot);
+    const isSupported = parseMajorVersion(versionMatrix.typia) === 12 &&
+        parseMajorVersion(versionMatrix["@typia/unplugin"]) === 12 &&
+        parseMajorVersion(versionMatrix["@wordpress/scripts"]) === 30 &&
+        parseMajorVersion(versionMatrix.webpack) === 5;
+    if (isSupported) {
+        return versionMatrix;
+    }
+    throw new Error([
+        "Unsupported Typia/Webpack toolchain for generated wp-typia projects.",
+        `Installed versions: ${formatInstalledMatrix(versionMatrix)}.`,
+        "Supported matrix: typia 12.x, @typia/unplugin 12.x, @wordpress/scripts 30.x with webpack 5.x.",
+        "Generated project defaults were tested against this matrix.",
+    ].join(" "));
+}
+export async function loadCompatibleTypiaWebpackPlugin({ importTypiaWebpackPlugin, projectRoot = process.cwd(), }) {
+    await assertTypiaWebpackCompatibility({ projectRoot });
+    const { default: UnpluginTypia } = await importTypiaWebpackPlugin();
+    return UnpluginTypia;
+}
 function mergeEntries(existingEntries, nextEntries, mode) {
     if (!nextEntries) {
         return existingEntries;
@@ -40,8 +130,11 @@ export function buildScaffoldBlockRegistration(metadata, overrides) {
         },
     };
 }
-export async function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset = (assetName) => /(^|\/)(interactivity|view)\.asset\.php$/.test(assetName), moduleEntriesMode = "merge", nonModuleEntriesMode = "merge", path, }) {
-    const { default: UnpluginTypia } = await importTypiaWebpackPlugin();
+export async function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset = (assetName) => /(^|\/)(interactivity|view)\.asset\.php$/.test(assetName), moduleEntriesMode = "merge", nonModuleEntriesMode = "merge", path, projectRoot = process.cwd(), }) {
+    const UnpluginTypia = await loadCompatibleTypiaWebpackPlugin({
+        importTypiaWebpackPlugin,
+        projectRoot,
+    });
     const resolvedDefaultConfig = typeof defaultConfig === "function"
         ? await defaultConfig()
         : defaultConfig;

package/dist/inspector-runtime.d.ts

@@ -3,7 +3,6 @@ import { type EditorFieldDescriptor, type EditorModelOptions, type ManifestDocum
 import { type ValidationResult } from "./validation.js";
 export type { EditorFieldDescriptor, EditorFieldOption, EditorModelOptions, ManifestAttribute, ManifestDocument, } from "./editor.js";
 export type { ValidationResult } from "./validation.js";
-type UnknownRecord = Record<string, unknown>;
 export interface InspectorSelectOption {
     label: string;
     value: string;
@@ -63,11 +62,11 @@ export interface InspectorComponentMap {
 export interface UseEditorFieldsResult {
     fields: EditorFieldDescriptor[];
     fieldMap: Map<string, EditorFieldDescriptor>;
-    getBooleanValue: (source: UnknownRecord, path: string, fallback: boolean) => boolean;
+    getBooleanValue: (source: object, path: string, fallback: boolean) => boolean;
     getField: (path: string) => EditorFieldDescriptor | undefined;
-    getNumberValue: (source: UnknownRecord, path: string, fallback: number) => number;
+    getNumberValue: (source: object, path: string, fallback: number) => number;
     getSelectOptions: (path: string, labelMap?: Record<string, string>) => InspectorSelectOption[];
-    getStringValue: (source: UnknownRecord, path: string, fallback: string) => string;
+    getStringValue: (source: object, path: string, fallback: string) => string;
     manualFields: EditorFieldDescriptor[];
     supportedFields: EditorFieldDescriptor[];
 }
@@ -112,7 +111,7 @@ export interface InspectorFieldOverride {
     renderUnsupported?: (context: FieldControlRenderContext) => ReactNode;
     step?: number;
 }
-export interface InspectorFromManifestProps<T extends UnknownRecord> {
+export interface InspectorFromManifestProps<T extends object> {
     attributes: T;
     children?: ReactNode;
     components?: InspectorComponentMap;
@@ -126,4 +125,4 @@ export interface InspectorFromManifestProps<T extends UnknownRecord> {
 export declare function useEditorFields(manifest: ManifestDocument, options?: EditorModelOptions): UseEditorFieldsResult;
 export declare function useTypedAttributeUpdater<T extends object>(attributes: T, setAttributes: (attrs: Partial<T>) => void, validate?: (value: T) => ValidationResult<T>): TypedAttributeUpdater<T>;
 export declare function FieldControl({ components, field, help, label, max, min, onChange, options, render, renderUnsupported, step, value, }: FieldControlProps): import("react/jsx-runtime").JSX.Element | null;
-export declare function InspectorFromManifest<T extends UnknownRecord>({ attributes, children, components, fieldLookup, fieldOverrides, initialOpen, onChange, paths, title, }: InspectorFromManifestProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function InspectorFromManifest<T extends object>({ attributes, children, components, fieldLookup, fieldOverrides, initialOpen, onChange, paths, title, }: InspectorFromManifestProps<T>): import("react/jsx-runtime").JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/block-runtime",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Generated-project runtime and metadata sync helpers for wp-typia",
   "type": "module",
   "main": "dist/index.js",