@fecommunity/reactpress-toolkit 3.0.4 → 3.7.0

package/dist/plugin/client/client.d.ts

@@ -0,0 +1,14 @@
+import { createApiInstance } from '../../api/instance';
+export declare class ApiError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}
+export interface ClientOptions {
+    baseURL?: string;
+    getAccessToken?: () => string | null | undefined;
+    onUnauthorized?: () => void;
+}
+export type ReactPressClient = ReturnType<typeof createApiInstance>;
+/** Single factory for web / theme / plugins — wraps generated API modules. */
+export declare function createClient(options?: ClientOptions): ReactPressClient;
+export declare function getDefaultApiBaseUrl(): string;

package/dist/plugin/client/client.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+exports.createClient = createClient;
+exports.getDefaultApiBaseUrl = getDefaultApiBaseUrl;
+const instance_1 = require("../../api/instance");
+class ApiError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.code = code;
+    }
+}
+exports.ApiError = ApiError;
+function readApiMessage(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed ? trimmed : null;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((item) => readApiMessage(item))
+            .filter((item) => Boolean(item));
+        return parts.length ? parts.join(', ') : null;
+    }
+    if (value && typeof value === 'object') {
+        const payload = value;
+        return readApiMessage(payload.message) ?? readApiMessage(payload.msg);
+    }
+    return null;
+}
+function rejectApiError(status, payload) {
+    if (typeof payload.code === 'number' && payload.code !== 0) {
+        return Promise.reject(new ApiError(payload.code, readApiMessage(payload.message) ?? 'Request failed'));
+    }
+    const message = readApiMessage(payload.msg) ?? readApiMessage(payload.message);
+    if (message) {
+        return Promise.reject(new ApiError(Number(payload.statusCode ?? status ?? 500), message));
+    }
+    return null;
+}
+function attachInterceptors(http, options) {
+    http.instance.interceptors.request.use((config) => {
+        const token = options.getAccessToken?.();
+        if (token && config.headers) {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+    });
+    http.instance.interceptors.response.use((response) => {
+        const body = response.data;
+        if (!body || typeof body !== 'object')
+            return response;
+        if (typeof body.code === 'number') {
+            if (body.code !== 0) {
+                throw new ApiError(body.code, readApiMessage(body.message) ?? 'Request failed');
+            }
+            response.data = body.data;
+            return response;
+        }
+        if (typeof body.success === 'boolean') {
+            if (!body.success) {
+                throw new ApiError(Number(body.statusCode ?? 500), readApiMessage(body.msg) ?? 'Request failed');
+            }
+            response.data = body.data;
+            return response;
+        }
+        return response;
+    }, (error) => {
+        const status = error?.response?.status;
+        if (status === 401) {
+            options.onUnauthorized?.();
+        }
+        const body = error?.response?.data;
+        if (body && typeof body === 'object') {
+            const rejected = rejectApiError(status, body);
+            if (rejected)
+                return rejected;
+        }
+        return Promise.reject(error);
+    });
+}
+/** Single factory for web / theme / plugins — wraps generated API modules. */
+function createClient(options = {}) {
+    const baseURL = options.baseURL ?? 'http://localhost:3002/api';
+    const client = (0, instance_1.createApiInstance)({ baseURL });
+    attachInterceptors(client.article.http, options);
+    return client;
+}
+function getDefaultApiBaseUrl() {
+    if (typeof process !== 'undefined' && process.env?.SERVER_API_URL) {
+        return process.env.SERVER_API_URL;
+    }
+    return 'http://localhost:3002/api';
+}

package/dist/plugin/client/index.d.ts

@@ -0,0 +1,4 @@
+export type { ClientOptions, ReactPressClient } from './client';
+export { ApiError, createClient, getDefaultApiBaseUrl } from './client';
+export type { AppRuntime, DesktopApi } from './runtime';
+export { getDesktopApi, getRuntime, resolveApiBaseUrl, } from './runtime';

package/dist/plugin/client/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveApiBaseUrl = exports.getRuntime = exports.getDesktopApi = exports.getDefaultApiBaseUrl = exports.createClient = exports.ApiError = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return client_1.ApiError; } });
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
+Object.defineProperty(exports, "getDefaultApiBaseUrl", { enumerable: true, get: function () { return client_1.getDefaultApiBaseUrl; } });
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "getDesktopApi", { enumerable: true, get: function () { return runtime_1.getDesktopApi; } });
+Object.defineProperty(exports, "getRuntime", { enumerable: true, get: function () { return runtime_1.getRuntime; } });
+Object.defineProperty(exports, "resolveApiBaseUrl", { enumerable: true, get: function () { return runtime_1.resolveApiBaseUrl; } });

package/dist/plugin/client/runtime.d.ts

@@ -0,0 +1,18 @@
+export type AppRuntime = 'web' | 'electron';
+export interface DesktopApi {
+    getApiBaseUrl: () => Promise<string>;
+    setApiBaseUrl: (url: string) => Promise<void>;
+    showSaveDialog: (opts: {
+        defaultPath?: string;
+    }) => Promise<string | undefined>;
+    openExternal: (url: string) => Promise<void>;
+    platform: NodeJS.Platform;
+}
+declare global {
+    interface Window {
+        reactpressDesktop?: DesktopApi;
+    }
+}
+export declare function getRuntime(): AppRuntime;
+export declare function getDesktopApi(): DesktopApi | undefined;
+export declare function resolveApiBaseUrl(fallback: string): Promise<string>;

package/dist/plugin/client/runtime.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntime = getRuntime;
+exports.getDesktopApi = getDesktopApi;
+exports.resolveApiBaseUrl = resolveApiBaseUrl;
+function getRuntime() {
+    if (typeof window !== 'undefined' && window.reactpressDesktop) {
+        return 'electron';
+    }
+    return 'web';
+}
+function getDesktopApi() {
+    if (typeof window === 'undefined')
+        return undefined;
+    return window.reactpressDesktop;
+}
+async function resolveApiBaseUrl(fallback) {
+    const desktop = getDesktopApi();
+    if (desktop) {
+        try {
+            const url = await desktop.getApiBaseUrl();
+            if (url)
+                return url;
+        }
+        catch {
+            // fall through
+        }
+    }
+    return fallback;
+}

package/dist/plugin/dev/index.d.ts

@@ -0,0 +1,4 @@
+export type { DevPortRedirectOptions, DevPortRole } from './portRedirect';
+export { isUnifiedNginxEntryEnabled } from './portRedirect';
+export { buildDevPortRedirectUrl, isDirectDevPortAccess, isNginxDevRedirectEnabled, isThemePreviewDevPort, resolveDevPortRole, resolveNginxEntryUrl, shouldRedirectDevPortToNginx, THEME_PREVIEW_DEV_PORTS, } from './portRedirect';
+export { devPortRedirectPlugin } from './vitePortRedirectPlugin';

package/dist/plugin/dev/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devPortRedirectPlugin = exports.THEME_PREVIEW_DEV_PORTS = exports.shouldRedirectDevPortToNginx = exports.resolveNginxEntryUrl = exports.resolveDevPortRole = exports.isThemePreviewDevPort = exports.isNginxDevRedirectEnabled = exports.isDirectDevPortAccess = exports.buildDevPortRedirectUrl = exports.isUnifiedNginxEntryEnabled = void 0;
+var portRedirect_1 = require("./portRedirect");
+Object.defineProperty(exports, "isUnifiedNginxEntryEnabled", { enumerable: true, get: function () { return portRedirect_1.isUnifiedNginxEntryEnabled; } });
+var portRedirect_2 = require("./portRedirect");
+Object.defineProperty(exports, "buildDevPortRedirectUrl", { enumerable: true, get: function () { return portRedirect_2.buildDevPortRedirectUrl; } });
+Object.defineProperty(exports, "isDirectDevPortAccess", { enumerable: true, get: function () { return portRedirect_2.isDirectDevPortAccess; } });
+Object.defineProperty(exports, "isNginxDevRedirectEnabled", { enumerable: true, get: function () { return portRedirect_2.isNginxDevRedirectEnabled; } });
+Object.defineProperty(exports, "isThemePreviewDevPort", { enumerable: true, get: function () { return portRedirect_2.isThemePreviewDevPort; } });
+Object.defineProperty(exports, "resolveDevPortRole", { enumerable: true, get: function () { return portRedirect_2.resolveDevPortRole; } });
+Object.defineProperty(exports, "resolveNginxEntryUrl", { enumerable: true, get: function () { return portRedirect_2.resolveNginxEntryUrl; } });
+Object.defineProperty(exports, "shouldRedirectDevPortToNginx", { enumerable: true, get: function () { return portRedirect_2.shouldRedirectDevPortToNginx; } });
+Object.defineProperty(exports, "THEME_PREVIEW_DEV_PORTS", { enumerable: true, get: function () { return portRedirect_2.THEME_PREVIEW_DEV_PORTS; } });
+var vitePortRedirectPlugin_1 = require("./vitePortRedirectPlugin");
+Object.defineProperty(exports, "devPortRedirectPlugin", { enumerable: true, get: function () { return vitePortRedirectPlugin_1.devPortRedirectPlugin; } });

package/dist/plugin/dev/portRedirect.d.ts

@@ -0,0 +1,26 @@
+/** Admin theme preview pool — must not redirect to nginx visitor (active theme). */
+export declare const THEME_PREVIEW_DEV_PORTS: number[];
+export type DevPortRole = 'visitor' | 'admin' | 'api' | 'preview';
+export declare function isThemePreviewDevPort(port: number): boolean;
+export declare function resolveDevPortRole(directPort: number): DevPortRole;
+/** Unified nginx entry (:80) — dev (`REACTPRESS_NGINX_ENTRY_URL`) or prod (`NGINX_ENTRY_URL`). */
+export declare function isUnifiedNginxEntryEnabled(): boolean;
+/** @deprecated Use {@link isUnifiedNginxEntryEnabled} */
+export declare function isNginxDevRedirectEnabled(): boolean;
+export declare function resolveNginxEntryUrl(): string;
+export declare function isDirectDevPortAccess(host: string | null | undefined, port: number): boolean;
+export interface DevPortRedirectOptions {
+    host?: string | null;
+    method?: string;
+    accept?: string | null;
+    directPort: number;
+    pathname?: string;
+    skipPathPrefixes?: string[];
+}
+export declare function shouldRedirectDevPortToNginx(options: DevPortRedirectOptions): boolean;
+export declare function buildDevPortRedirectUrl(options: {
+    directPort: number;
+    pathname?: string;
+    search?: string;
+    nginxEntryUrl?: string;
+}): string;

package/dist/plugin/dev/portRedirect.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THEME_PREVIEW_DEV_PORTS = void 0;
+exports.isThemePreviewDevPort = isThemePreviewDevPort;
+exports.resolveDevPortRole = resolveDevPortRole;
+exports.isUnifiedNginxEntryEnabled = isUnifiedNginxEntryEnabled;
+exports.isNginxDevRedirectEnabled = isNginxDevRedirectEnabled;
+exports.resolveNginxEntryUrl = resolveNginxEntryUrl;
+exports.isDirectDevPortAccess = isDirectDevPortAccess;
+exports.shouldRedirectDevPortToNginx = shouldRedirectDevPortToNginx;
+exports.buildDevPortRedirectUrl = buildDevPortRedirectUrl;
+const DEFAULT_NGINX_PORT = 80;
+/** Admin theme preview pool — must not redirect to nginx visitor (active theme). */
+exports.THEME_PREVIEW_DEV_PORTS = [3003, 3004, 3005, 3006, 3007, 3008];
+function isThemePreviewDevPort(port) {
+    return Number.isInteger(port) && exports.THEME_PREVIEW_DEV_PORTS.includes(port);
+}
+function readPortEnv(key, fallback) {
+    const raw = process.env[key]?.trim();
+    if (!raw)
+        return fallback;
+    const parsed = parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveDevPortRole(directPort) {
+    if (isThemePreviewDevPort(directPort))
+        return 'preview';
+    const apiPort = readPortEnv('SERVER_PORT', 3002);
+    const adminPort = readPortEnv('WEB_ADMIN_PORT', 3000);
+    if (directPort === apiPort)
+        return 'api';
+    if (directPort === adminPort)
+        return 'admin';
+    return 'visitor';
+}
+/** Unified nginx entry (:80) — dev (`REACTPRESS_NGINX_ENTRY_URL`) or prod (`NGINX_ENTRY_URL`). */
+function isUnifiedNginxEntryEnabled() {
+    return Boolean(process.env.REACTPRESS_NGINX_ENTRY_URL?.trim() || process.env.NGINX_ENTRY_URL?.trim());
+}
+/** @deprecated Use {@link isUnifiedNginxEntryEnabled} */
+function isNginxDevRedirectEnabled() {
+    return isUnifiedNginxEntryEnabled();
+}
+function resolveNginxEntryUrl() {
+    const override = process.env.REACTPRESS_NGINX_ENTRY_URL?.trim();
+    if (override) {
+        return override.replace(/\/$/, '');
+    }
+    const rawPort = process.env.NGINX_PORT?.trim();
+    const port = rawPort ? parseInt(rawPort, 10) : DEFAULT_NGINX_PORT;
+    if (Number.isFinite(port) && port > 0 && port !== DEFAULT_NGINX_PORT) {
+        return `http://localhost:${port}`;
+    }
+    return 'http://localhost';
+}
+function isDirectDevPortAccess(host, port) {
+    if (!host || !Number.isFinite(port) || port <= 0)
+        return false;
+    const normalized = host.toLowerCase();
+    return (normalized === `localhost:${port}` ||
+        normalized === `127.0.0.1:${port}` ||
+        normalized === `[::1]:${port}`);
+}
+function acceptsHtmlNavigation(accept) {
+    if (!accept)
+        return false;
+    return accept.includes('text/html');
+}
+function shouldRedirectDevPortToNginx(options) {
+    if (process.env.REACTPRESS_SKIP_DEV_PORT_REDIRECT === '1')
+        return false;
+    if (isThemePreviewDevPort(options.directPort))
+        return false;
+    if (!isUnifiedNginxEntryEnabled())
+        return false;
+    const method = (options.method || 'GET').toUpperCase();
+    if (method !== 'GET' && method !== 'HEAD')
+        return false;
+    if (!isDirectDevPortAccess(options.host, options.directPort))
+        return false;
+    if (!acceptsHtmlNavigation(options.accept))
+        return false;
+    const pathname = options.pathname || '/';
+    if (options.skipPathPrefixes?.some((prefix) => pathname.startsWith(prefix))) {
+        return false;
+    }
+    return true;
+}
+function buildDevPortRedirectUrl(options) {
+    const entry = (options.nginxEntryUrl || resolveNginxEntryUrl()).replace(/\/$/, '');
+    const pathname = options.pathname || '/';
+    const search = options.search || '';
+    const role = resolveDevPortRole(options.directPort);
+    if (role === 'api') {
+        if (pathname === '/' || pathname === '') {
+            return `${entry}/api${search}`;
+        }
+        return `${entry}${pathname}${search}`;
+    }
+    if (role === 'admin') {
+        let adminPath = pathname;
+        if (!adminPath.startsWith('/admin')) {
+            adminPath = adminPath === '/' ? '/admin/' : `/admin${adminPath.startsWith('/') ? adminPath : `/${adminPath}`}`;
+        }
+        return `${entry}${adminPath}${search}`;
+    }
+    if (role === 'preview') {
+        return `${entry}${pathname}${search}`;
+    }
+    return `${entry}${pathname}${search}`;
+}

package/dist/plugin/dev/vitePortRedirectPlugin.d.ts

@@ -0,0 +1,24 @@
+type DevServer = {
+    middlewares: {
+        use: (handler: (req: DevRequest, res: DevResponse, next: () => void) => void) => void;
+    };
+};
+type DevRequest = {
+    url?: string;
+    method?: string;
+    headers: {
+        host?: string;
+        accept?: string;
+    };
+};
+type DevResponse = {
+    statusCode: number;
+    setHeader: (name: string, value: string) => void;
+    end: () => void;
+};
+/** Redirect direct :3000 browser hits to nginx entry when REACTPRESS_NGINX_ENTRY_URL is set. */
+export declare function devPortRedirectPlugin(port: number): {
+    name: string;
+    configureServer(server: DevServer): void;
+};
+export {};

package/dist/plugin/dev/vitePortRedirectPlugin.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devPortRedirectPlugin = devPortRedirectPlugin;
+const portRedirect_1 = require("./portRedirect");
+const VITE_DEV_SKIP_PREFIXES = ['/@vite', '/@fs', '/@id', '/node_modules'];
+function createRedirectMiddleware(port) {
+    return (req, res, next) => {
+        const url = req.url || '/';
+        const pathname = url.split('?')[0] || '/';
+        const search = url.includes('?') ? url.slice(url.indexOf('?')) : '';
+        if (!(0, portRedirect_1.shouldRedirectDevPortToNginx)({
+            host: req.headers.host,
+            method: req.method,
+            accept: req.headers.accept,
+            directPort: port,
+            pathname,
+            skipPathPrefixes: VITE_DEV_SKIP_PREFIXES,
+        })) {
+            next();
+            return;
+        }
+        const target = (0, portRedirect_1.buildDevPortRedirectUrl)({
+            directPort: port,
+            pathname,
+            search,
+        });
+        res.statusCode = 302;
+        res.setHeader('Location', target);
+        res.end();
+    };
+}
+/** Redirect direct :3000 browser hits to nginx entry when REACTPRESS_NGINX_ENTRY_URL is set. */
+function devPortRedirectPlugin(port) {
+    return {
+        name: 'reactpress-dev-port-redirect',
+        configureServer(server) {
+            server.middlewares.use(createRedirectMiddleware(port));
+        },
+    };
+}

package/dist/plugin/extension/index.d.ts

@@ -0,0 +1,4 @@
+export * from './plugin';
+export * from './plugin-admin-locale';
+export * from './security';
+export * from './validate';

package/dist/plugin/extension/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./plugin-admin-locale"), exports);
+__exportStar(require("./security"), exports);
+__exportStar(require("./validate"), exports);

package/dist/plugin/extension/plugin-admin-locale.d.ts

@@ -0,0 +1,21 @@
+import { getNestedLocaleString, getNestedLocaleValue } from '../../utils/object';
+/** Admin copy shipped with the plugin (`locales/{locale}.json`). */
+export type PluginAdminLocaleMessages = Record<string, unknown>;
+export declare const PLUGIN_LOCALE_DIR = "locales";
+export { getNestedLocaleString, getNestedLocaleValue };
+type PluginSchemaProperty = {
+    type?: string;
+    title?: string;
+    description?: string;
+    properties?: Record<string, PluginSchemaProperty>;
+    items?: PluginSchemaProperty | PluginSchemaProperty[];
+};
+export type PluginSettingsSchema = Record<string, unknown> & {
+    title?: string;
+    description?: string;
+    properties?: Record<string, PluginSchemaProperty>;
+};
+/** Resolve admin copy from plugin locale bundle; falls back to manifest text. */
+export declare function resolvePluginAdminLocaleText(messages: PluginAdminLocaleMessages | null | undefined, dotPath: string, fallback?: string): string;
+/** Apply plugin admin locale messages to settings JSON Schema titles/descriptions. */
+export declare function localizePluginSettingsSchemaWithLocale(schema: PluginSettingsSchema | null | undefined, messages: PluginAdminLocaleMessages | null | undefined): PluginSettingsSchema | null;

package/dist/plugin/extension/plugin-admin-locale.io.d.ts

@@ -0,0 +1,2 @@
+import { type PluginAdminLocaleMessages } from './plugin-admin-locale';
+export declare function readPluginAdminLocaleFile(pluginDir: string, locale: string): PluginAdminLocaleMessages | null;

package/dist/plugin/extension/plugin-admin-locale.io.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPluginAdminLocaleFile = readPluginAdminLocaleFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plugin_admin_locale_1 = require("./plugin-admin-locale");
+function readPluginAdminLocaleFile(pluginDir, locale) {
+    const safeLocale = /^[a-z]{2}(?:-[a-z]{2})?$/i.test(locale) ? locale : 'en';
+    const filePath = path.join(pluginDir, plugin_admin_locale_1.PLUGIN_LOCALE_DIR, `${safeLocale}.json`);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return raw && typeof raw === 'object' && !Array.isArray(raw)
+            ? raw
+            : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/plugin/extension/plugin-admin-locale.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestedLocaleValue = exports.getNestedLocaleString = exports.PLUGIN_LOCALE_DIR = void 0;
+exports.resolvePluginAdminLocaleText = resolvePluginAdminLocaleText;
+exports.localizePluginSettingsSchemaWithLocale = localizePluginSettingsSchemaWithLocale;
+const object_1 = require("../../utils/object");
+Object.defineProperty(exports, "getNestedLocaleString", { enumerable: true, get: function () { return object_1.getNestedLocaleString; } });
+Object.defineProperty(exports, "getNestedLocaleValue", { enumerable: true, get: function () { return object_1.getNestedLocaleValue; } });
+exports.PLUGIN_LOCALE_DIR = 'locales';
+/** Resolve admin copy from plugin locale bundle; falls back to manifest text. */
+function resolvePluginAdminLocaleText(messages, dotPath, fallback) {
+    const fromLocale = messages ? (0, object_1.getNestedLocaleString)(messages, dotPath) : undefined;
+    if (fromLocale)
+        return fromLocale;
+    return fallback?.trim() ?? '';
+}
+function localizeSchemaField(field, pathParts, resolve) {
+    if (typeof field.title === 'string') {
+        field.title = resolve([...pathParts, 'title'].join('.'), field.title);
+    }
+    if (typeof field.description === 'string') {
+        field.description = resolve([...pathParts, 'description'].join('.'), field.description);
+    }
+    if (field.properties) {
+        for (const [key, child] of Object.entries(field.properties)) {
+            localizeSchemaField(child, [...pathParts, key], resolve);
+        }
+    }
+    const items = field.items;
+    if (items && typeof items === 'object' && !Array.isArray(items)) {
+        const itemSchema = items;
+        if (itemSchema.properties) {
+            for (const [key, child] of Object.entries(itemSchema.properties)) {
+                localizeSchemaField(child, [...pathParts, 'items', key], resolve);
+            }
+        }
+        else {
+            localizeSchemaField(itemSchema, [...pathParts, 'items'], resolve);
+        }
+    }
+}
+/** Apply plugin admin locale messages to settings JSON Schema titles/descriptions. */
+function localizePluginSettingsSchemaWithLocale(schema, messages) {
+    if (!schema)
+        return null;
+    const out = structuredClone(schema);
+    const resolve = (dotPath, fallback) => resolvePluginAdminLocaleText(messages, `settings.${dotPath}`, fallback);
+    if (typeof out.title === 'string') {
+        out.title = resolve('title', out.title);
+    }
+    if (typeof out.description === 'string') {
+        out.description = resolve('description', out.description);
+    }
+    if (out.properties) {
+        for (const [key, field] of Object.entries(out.properties)) {
+            localizeSchemaField(field, [key], resolve);
+        }
+    }
+    return out;
+}

package/dist/plugin/extension/plugin.d.ts

@@ -0,0 +1,82 @@
+/** WordPress-style plugin manifest and site plugin state (shared by server / web). */
+import type { AdminSlotId } from '../admin/slots';
+export interface PluginServerManifest {
+    module: string;
+    hooks?: {
+        subscribe?: string[];
+        provide?: string[];
+    };
+}
+export interface PluginAdminMenuManifest {
+    parent?: string;
+    title: string;
+    path: string;
+    permission?: string;
+    sort?: number;
+}
+/** Declarative admin UI — mirrors `server.hooks.subscribe` for Admin slots. */
+export interface PluginAdminSlotsManifest {
+    /** Built-in slot ids this plugin mounts UI into (see `AdminSlotIds`). */
+    subscribe?: AdminSlotId[];
+}
+export interface PluginAdminManifest {
+    /** @deprecated Use convention `admin/index.ts`; declared slots drive loading. */
+    entry?: string;
+    slots?: PluginAdminSlotsManifest;
+    menu?: PluginAdminMenuManifest;
+}
+export interface PluginSettingsManifest {
+    schema?: Record<string, unknown>;
+}
+export interface PluginCapabilities {
+    headless?: boolean;
+    network?: boolean;
+    filesystem?: boolean;
+    database?: boolean;
+}
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    requires?: string;
+    requiresPlugins?: string[];
+    server?: PluginServerManifest;
+    admin?: PluginAdminManifest;
+    settings?: PluginSettingsManifest;
+    permissions?: string[];
+    capabilities?: PluginCapabilities;
+}
+export interface PluginEntryMeta {
+    version: string;
+    source: 'local' | 'npm';
+    config?: Record<string, unknown>;
+    activatedAt?: string;
+    npm?: {
+        spec: string;
+        resolvedVersion?: string;
+        packageName?: string;
+        installedAt?: string;
+    };
+    loadError?: string;
+}
+export interface SitePluginState {
+    installedPlugins: string[];
+    activePlugins: string[];
+    entries: Record<string, PluginEntryMeta>;
+}
+export declare const defaultSitePluginState: SitePluginState;
+export interface GlobalSettingWithPlugins {
+    theme?: unknown;
+    plugins?: SitePluginState;
+    [key: string]: unknown;
+}
+export declare function isValidPluginId(id: string): boolean;
+export declare function parsePluginManifest(raw: unknown): PluginManifest | null;
+export declare function getPluginStateFromGlobalSetting(raw: unknown): SitePluginState;
+export declare function mergePluginStateIntoGlobalSetting(raw: unknown, patch: Partial<SitePluginState>): GlobalSettingWithPlugins;
+/** Conventional admin module path relative to plugin package root. */
+export declare const PLUGIN_ADMIN_MODULE_CONVENTION = "admin/index";
+/** Whether manifest declares admin UI (slot and/or settings menu). */
+export declare function pluginManifestHasAdminUI(admin: PluginAdminManifest | undefined): boolean;