@fcannizzaro/streamdeck-react 0.1.13 → 0.1.14

package/dist/action.d.ts

@@ -1,3 +1,3 @@
-import { ActionConfigInput, ActionDefinition } from './types';
+import { ActionConfig, ActionDefinition } from './types';
 import { JsonObject } from '@elgato/utils';
-export declare function defineAction<S extends JsonObject = JsonObject>(config: ActionConfigInput<S>): ActionDefinition<S>;
+export declare function defineAction<S extends JsonObject = JsonObject>(config: ActionConfig<S>): ActionDefinition<S>;

package/dist/action.js

@@ -7,7 +7,8 @@ function defineAction(config) {
 		touchStrip: config.touchStrip,
 		dialLayout: config.dialLayout,
 		wrapper: config.wrapper,
-		defaultSettings: config.defaultSettings ?? {}
+		defaultSettings: config.defaultSettings ?? {},
+		info: config.info
 	};
 }
 //#endregion

package/dist/bundler-shared.d.ts

@@ -53,3 +53,24 @@ export declare function expandTargets(targets: StreamDeckTarget[]): ResolvedTarg
  * In production: missing bindings throw an error (the plugin won't work).
  */
 export declare function copyNativeBindings(outDir: string, isDevelopment: boolean, options: StreamDeckTargetOptions, warn: (message: string) => void): void;
+/**
+ * Resolve the .sdPlugin directory root from the bundler output directory.
+ *
+ * Strategy:
+ *   1. Walk up from outDir looking for a parent named `*.sdPlugin`
+ *   2. If not found, assume outDir's parent is the .sdPlugin root
+ *      (handles `<uuid>.sdPlugin/bin/` → `<uuid>.sdPlugin/`)
+ *
+ * @returns The .sdPlugin directory path, or `null` if unresolvable.
+ */
+export declare function resolvePluginDir(outDir: string): string | null;
+/**
+ * Derive the CodePath (manifest entry point) from the bundler output
+ * file path, relative to the .sdPlugin directory.
+ *
+ * Example:
+ *   outFile: "/project/com.example.sdPlugin/bin/plugin.mjs"
+ *   pluginDir: "/project/com.example.sdPlugin"
+ *   → "bin/plugin.mjs"
+ */
+export declare function deriveCodePath(outFile: string, pluginDir: string): string;

package/dist/bundler-shared.js

@@ -1,4 +1,4 @@
-import { dirname, join } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { copyFileSync, existsSync } from "node:fs";
 //#region src/bundler-shared.ts
@@ -155,5 +155,40 @@ function copyNativeBindings(outDir, isDevelopment, options, warn) {
 		throw new Error(`[@fcannizzaro/streamdeck-react] Failed to copy native binding: ${String(err)}`);
 	}
 }
+/**
+* Resolve the .sdPlugin directory root from the bundler output directory.
+*
+* Strategy:
+*   1. Walk up from outDir looking for a parent named `*.sdPlugin`
+*   2. If not found, assume outDir's parent is the .sdPlugin root
+*      (handles `<uuid>.sdPlugin/bin/` → `<uuid>.sdPlugin/`)
+*
+* @returns The .sdPlugin directory path, or `null` if unresolvable.
+*/
+function resolvePluginDir(outDir) {
+	let dir = outDir;
+	const root = dirname(dir);
+	for (let i = 0; i < 4; i++) {
+		if (dir.endsWith(".sdPlugin")) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	const parent = dirname(outDir);
+	if (parent !== root && parent.endsWith(".sdPlugin")) return parent;
+	return null;
+}
+/**
+* Derive the CodePath (manifest entry point) from the bundler output
+* file path, relative to the .sdPlugin directory.
+*
+* Example:
+*   outFile: "/project/com.example.sdPlugin/bin/plugin.mjs"
+*   pluginDir: "/project/com.example.sdPlugin"
+*   → "bin/plugin.mjs"
+*/
+function deriveCodePath(outFile, pluginDir) {
+	return relative(pluginDir, outFile).replace(/\\/g, "/");
+}
 //#endregion
-export { NOOP_DEVTOOLS_CODE, NOOP_DEVTOOLS_ID, TAKUMI_NATIVE_LOADER_CODE, TAKUMI_NATIVE_LOADER_ID, copyNativeBindings, isDevelopmentMode, isLibraryDevtoolsImport, shouldStripDevtools };
+export { NOOP_DEVTOOLS_CODE, NOOP_DEVTOOLS_ID, TAKUMI_NATIVE_LOADER_CODE, TAKUMI_NATIVE_LOADER_ID, copyNativeBindings, deriveCodePath, isDevelopmentMode, isLibraryDevtoolsImport, resolvePluginDir, shouldStripDevtools };

package/dist/index.d.ts

@@ -25,7 +25,8 @@ export { ErrorBoundary } from './components/ErrorBoundary';
 export { tw } from './tw/index';
 export { googleFont } from './google-font';
 export type { GoogleFontVariant } from './google-font';
-export type { PluginConfig, Plugin, FontConfig, ActionConfig, ActionConfigInput, ActionDefinition, ActionUUID, ManifestActions, EncoderLayout, WrapperComponent, TakumiBackend, Controller, Coordinates, Size, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload, } from './types';
+export type { PluginConfig, Plugin, FontConfig, ActionConfig, ActionDefinition, EncoderLayout, WrapperComponent, TakumiBackend, Controller, Coordinates, Size, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload, } from './types';
+export type { PluginManifestInfo, ActionManifestInfo, ManifestController, ManifestEncoderInfo, ManifestTriggerDescription, ManifestStateInfo, ManifestOSInfo, ManifestNodejsInfo, ManifestProfileInfo, } from './manifest-types';
 export type { TapOptions, LongPressOptions, DoubleTapOptions } from './hooks/gestures';
 export type { BoxProps } from './components/Box';
 export type { TextProps } from './components/Text';

package/dist/manifest-extract.d.ts

@@ -0,0 +1,32 @@
+import { ActionManifestInfo, ManifestActionSource } from './manifest-types';
+type ASTNode = Record<string, any>;
+export interface ExtractedAction {
+    uuid: string;
+    hasKey: boolean;
+    hasDial: boolean;
+    hasTouchStrip: boolean;
+    info: ActionManifestInfo | null;
+}
+/**
+ * Extract all `defineAction()` calls from an ESTree-compatible AST.
+ *
+ * Walks the entire AST looking for `defineAction({ uuid, key?, dial?,
+ * touchStrip?, info? })` patterns and returns the extracted metadata.
+ *
+ * Actions with `info.disabled: true` are included in the results but
+ * can be filtered by the caller.
+ *
+ * @param ast - ESTree-compatible AST (from Rollup's `this.parse()` or `moduleParsed`)
+ * @returns Array of extracted action metadata
+ */
+export declare function extractActionsFromAST(ast: ASTNode): ExtractedAction[];
+/**
+ * Convert an ExtractedAction to a ManifestActionSource for the
+ * manifest generation engine.
+ *
+ * The `key`/`dial`/`touchStrip` fields are set to `true` (truthy)
+ * when the corresponding property was present in the defineAction()
+ * call, enabling the controller derivation logic in manifest-gen.ts.
+ */
+export declare function extractedToActionSource(extracted: ExtractedAction): ManifestActionSource;
+export {};

package/dist/manifest-extract.js

@@ -0,0 +1,141 @@
+//#region src/manifest-extract.ts
+var SKIP_KEYS = new Set([
+	"type",
+	"start",
+	"end",
+	"loc",
+	"range"
+]);
+function walkAST(node, visitor) {
+	if (!node || typeof node !== "object" || !node.type) return;
+	visitor(node);
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && item.type) walkAST(item, visitor);
+		} else if (child && typeof child === "object" && child.type) walkAST(child, visitor);
+	}
+}
+var UNEVALUABLE = Symbol("unevaluable");
+function evaluateStatic(node) {
+	if (!node) return UNEVALUABLE;
+	switch (node.type) {
+		case "Literal": return node.value;
+		case "ObjectExpression": {
+			const obj = {};
+			for (const prop of node.properties ?? []) {
+				if (prop.type === "SpreadElement") return UNEVALUABLE;
+				if (prop.type !== "Property") continue;
+				if (prop.computed) return UNEVALUABLE;
+				const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
+				if (typeof key !== "string") return UNEVALUABLE;
+				const value = evaluateStatic(prop.value);
+				if (value === UNEVALUABLE) return UNEVALUABLE;
+				obj[key] = value;
+			}
+			return obj;
+		}
+		case "ArrayExpression": {
+			const arr = [];
+			for (const el of node.elements ?? []) {
+				if (!el) {
+					arr.push(null);
+					continue;
+				}
+				if (el.type === "SpreadElement") return UNEVALUABLE;
+				const value = evaluateStatic(el);
+				if (value === UNEVALUABLE) return UNEVALUABLE;
+				arr.push(value);
+			}
+			return arr;
+		}
+		case "UnaryExpression":
+			if (node.operator === "-" && node.argument?.type === "Literal" && typeof node.argument.value === "number") return -node.argument.value;
+			if (node.operator === "!") {
+				const arg = evaluateStatic(node.argument);
+				if (arg === UNEVALUABLE) return UNEVALUABLE;
+				return !arg;
+			}
+			return UNEVALUABLE;
+		case "TemplateLiteral":
+			if (node.expressions?.length === 0 && node.quasis?.length === 1) return node.quasis[0]?.value?.cooked;
+			return UNEVALUABLE;
+		default: return UNEVALUABLE;
+	}
+}
+function isDefineActionCall(node) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	return callee?.type === "Identifier" && callee.name === "defineAction";
+}
+function extractFromDefineAction(node) {
+	const args = node.arguments;
+	if (!args || args.length === 0) return null;
+	const arg = args[0];
+	if (arg.type !== "ObjectExpression") return null;
+	const propMap = /* @__PURE__ */ new Map();
+	for (const prop of arg.properties ?? []) {
+		if (prop.type !== "Property" || prop.computed) continue;
+		const key = prop.key?.type === "Identifier" ? prop.key.name : prop.key?.value;
+		if (typeof key === "string") propMap.set(key, prop.value);
+	}
+	const uuidNode = propMap.get("uuid");
+	if (!uuidNode || uuidNode.type !== "Literal" || typeof uuidNode.value !== "string") return null;
+	const infoNode = propMap.get("info");
+	let info = null;
+	if (infoNode) {
+		const evaluated = evaluateStatic(infoNode);
+		if (evaluated !== UNEVALUABLE && typeof evaluated === "object" && evaluated !== null) {
+			const candidate = evaluated;
+			if (typeof candidate.name === "string" && typeof candidate.icon === "string") info = candidate;
+		}
+	}
+	return {
+		uuid: uuidNode.value,
+		hasKey: propMap.has("key"),
+		hasDial: propMap.has("dial"),
+		hasTouchStrip: propMap.has("touchStrip"),
+		info
+	};
+}
+/**
+* Extract all `defineAction()` calls from an ESTree-compatible AST.
+*
+* Walks the entire AST looking for `defineAction({ uuid, key?, dial?,
+* touchStrip?, info? })` patterns and returns the extracted metadata.
+*
+* Actions with `info.disabled: true` are included in the results but
+* can be filtered by the caller.
+*
+* @param ast - ESTree-compatible AST (from Rollup's `this.parse()` or `moduleParsed`)
+* @returns Array of extracted action metadata
+*/
+function extractActionsFromAST(ast) {
+	const results = [];
+	walkAST(ast, (node) => {
+		if (!isDefineActionCall(node)) return;
+		const extracted = extractFromDefineAction(node);
+		if (extracted) results.push(extracted);
+	});
+	return results;
+}
+/**
+* Convert an ExtractedAction to a ManifestActionSource for the
+* manifest generation engine.
+*
+* The `key`/`dial`/`touchStrip` fields are set to `true` (truthy)
+* when the corresponding property was present in the defineAction()
+* call, enabling the controller derivation logic in manifest-gen.ts.
+*/
+function extractedToActionSource(extracted) {
+	return {
+		uuid: extracted.uuid,
+		key: extracted.hasKey ? true : void 0,
+		dial: extracted.hasDial ? true : void 0,
+		touchStrip: extracted.hasTouchStrip ? true : void 0,
+		info: extracted.info ?? void 0
+	};
+}
+//#endregion
+export { extractActionsFromAST, extractedToActionSource };

package/dist/manifest-gen.d.ts

@@ -0,0 +1,52 @@
+import { ManifestConfig } from './manifest-types';
+export interface ManifestValidationError {
+    field: string;
+    message: string;
+}
+/**
+ * Validate just the plugin UUID format.
+ *
+ * Used in `buildStart` for early error reporting before action
+ * extraction is complete.
+ *
+ * @returns A validation error if the UUID is invalid, or `null` if valid.
+ */
+export declare function validatePluginUUID(uuid: string): ManifestValidationError | null;
+/**
+ * Validate a full ManifestConfig for correctness.
+ *
+ * Checks:
+ *   - All action UUIDs are prefixed with the plugin UUID
+ *   - No duplicate action UUIDs
+ *   - Plugin UUID matches reverse-DNS pattern
+ *
+ * Called in `writeBundle` after action extraction is complete.
+ */
+export declare function validateManifestConfig(config: ManifestConfig, warn?: (msg: string) => void): ManifestValidationError[];
+type JsonRecord = Record<string, any>;
+/**
+ * Build the full manifest JSON object from a ManifestConfig.
+ *
+ * Applies all auto-derivation defaults and transforms camelCase
+ * to the PascalCase format expected by the Elgato schema.
+ *
+ * @param config - The manifest configuration
+ * @param codePath - Override CodePath (typically derived from bundler output)
+ */
+export declare function buildManifestJson(config: ManifestConfig, codePath?: string): JsonRecord;
+/**
+ * Generate the full manifest JSON string from a ManifestConfig.
+ *
+ * @param config - The manifest configuration
+ * @param codePath - Override CodePath (typically derived from bundler output)
+ * @returns Formatted JSON string
+ */
+export declare function generateManifestJsonString(config: ManifestConfig, codePath?: string): string;
+/**
+ * Write manifest.json only when the content has changed.
+ * Creates the parent directory if it does not exist.
+ *
+ * @returns `true` if the file was written, `false` if content was unchanged.
+ */
+export declare function writeManifestIfChanged(outPath: string, content: string): boolean;
+export {};

package/dist/manifest-gen.js

@@ -0,0 +1,229 @@
+import { dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/manifest-gen.ts
+/**
+* Validate just the plugin UUID format.
+*
+* Used in `buildStart` for early error reporting before action
+* extraction is complete.
+*
+* @returns A validation error if the UUID is invalid, or `null` if valid.
+*/
+function validatePluginUUID(uuid) {
+	if (!/^([a-z0-9-]+)(\.[a-z0-9-]+)+$/.test(uuid)) return {
+		field: "uuid",
+		message: `Plugin UUID "${uuid}" must be in reverse-DNS format (lowercase alphanumeric, hyphens, periods)`
+	};
+	return null;
+}
+/**
+* Validate a full ManifestConfig for correctness.
+*
+* Checks:
+*   - All action UUIDs are prefixed with the plugin UUID
+*   - No duplicate action UUIDs
+*   - Plugin UUID matches reverse-DNS pattern
+*
+* Called in `writeBundle` after action extraction is complete.
+*/
+function validateManifestConfig(config, warn) {
+	const errors = [];
+	const uuidError = validatePluginUUID(config.uuid);
+	if (uuidError) errors.push(uuidError);
+	const prefix = config.uuid + ".";
+	const seenUuids = /* @__PURE__ */ new Set();
+	for (const action of config.actions) {
+		if (!action.uuid.startsWith(prefix)) {
+			const error = {
+				field: `actions[${action.uuid}].uuid`,
+				message: `Action UUID "${action.uuid}" must be prefixed with plugin UUID "${config.uuid}."`
+			};
+			errors.push(error);
+			warn?.(`[@fcannizzaro/streamdeck-react] ${error.message}`);
+		}
+		if (seenUuids.has(action.uuid)) errors.push({
+			field: `actions[${action.uuid}].uuid`,
+			message: `Duplicate action UUID "${action.uuid}"`
+		});
+		seenUuids.add(action.uuid);
+	}
+	return errors;
+}
+/** Add a key to the record only if the value is defined. */
+function addIf(record, key, value) {
+	if (value !== void 0 && value !== null) record[key] = value;
+}
+function buildTriggerDescription(td) {
+	const out = {};
+	addIf(out, "Rotate", td.rotate);
+	addIf(out, "Push", td.push);
+	addIf(out, "Touch", td.touch);
+	addIf(out, "LongTouch", td.longTouch);
+	return out;
+}
+function buildEncoder(encoder) {
+	const out = {};
+	addIf(out, "layout", encoder.layout);
+	addIf(out, "Icon", encoder.icon);
+	addIf(out, "StackColor", encoder.stackColor);
+	addIf(out, "background", encoder.background);
+	if (encoder.triggerDescription) out["TriggerDescription"] = buildTriggerDescription(encoder.triggerDescription);
+	return out;
+}
+function buildState(state) {
+	const out = { Image: state.image };
+	addIf(out, "Name", state.name);
+	addIf(out, "Title", state.title);
+	addIf(out, "ShowTitle", state.showTitle);
+	addIf(out, "TitleAlignment", state.titleAlignment);
+	addIf(out, "TitleColor", state.titleColor);
+	addIf(out, "FontFamily", state.fontFamily);
+	addIf(out, "FontSize", state.fontSize);
+	addIf(out, "FontStyle", state.fontStyle);
+	addIf(out, "FontUnderline", state.fontUnderline);
+	addIf(out, "MultiActionImage", state.multiActionImage);
+	return out;
+}
+/**
+* Derive Controllers from an action definition.
+*
+* Priority:
+*   1. Explicit `controllers` on info → use as-is
+*   2. Derived from key/dial/touchStrip presence:
+*      - key → includes "Keypad"
+*      - dial or touchStrip → includes "Encoder"
+*      - both → ["Keypad", "Encoder"]
+*   3. Default → ["Keypad"]
+*/
+function deriveControllers(action) {
+	const info = action.info;
+	if (info?.controllers) return info.controllers.filter((c) => c != null);
+	const hasKey = action.key != null;
+	const hasEncoder = action.dial != null || action.touchStrip != null;
+	if (hasKey && hasEncoder) return ["Keypad", "Encoder"];
+	if (hasEncoder) return ["Encoder"];
+	if (hasKey) return ["Keypad"];
+	if (info?.encoder) return ["Encoder"];
+	return ["Keypad"];
+}
+function buildAction(action) {
+	const info = action.info;
+	if (!info) throw new Error(`[@fcannizzaro/streamdeck-react] Action "${action.uuid}" is missing \`info\`. Add info: { name, icon } to the defineAction() call.`);
+	const controllers = deriveControllers(action);
+	const states = info.states ? info.states.map(buildState) : [{ Image: info.icon }];
+	const out = {
+		UUID: action.uuid,
+		Name: info.name,
+		Icon: info.icon,
+		Controllers: controllers,
+		States: states
+	};
+	addIf(out, "Tooltip", info.tooltip);
+	addIf(out, "DisableAutomaticStates", info.disableAutomaticStates);
+	addIf(out, "DisableCaching", info.disableCaching);
+	addIf(out, "SupportedInMultiActions", info.supportedInMultiActions);
+	addIf(out, "SupportedInKeyLogicActions", info.supportedInKeyLogicActions);
+	addIf(out, "VisibleInActionsList", info.visibleInActionsList);
+	addIf(out, "UserTitleEnabled", info.userTitleEnabled);
+	addIf(out, "PropertyInspectorPath", info.propertyInspectorPath);
+	addIf(out, "SupportURL", info.supportUrl);
+	if (info.encoder) out["Encoder"] = buildEncoder(info.encoder);
+	if (info.os) out["OS"] = info.os;
+	return out;
+}
+var DEFAULT_OS = [{
+	platform: "mac",
+	minimumVersion: "13"
+}, {
+	platform: "windows",
+	minimumVersion: "10"
+}];
+function buildOS(osEntries) {
+	return osEntries.filter((o) => o != null).map((o) => ({
+		Platform: o.platform,
+		MinimumVersion: o.minimumVersion
+	}));
+}
+function buildNodejs(nodejs) {
+	const out = { Version: nodejs.version };
+	addIf(out, "Debug", nodejs.debug);
+	addIf(out, "GenerateProfilerOutput", nodejs.generateProfilerOutput);
+	return out;
+}
+function buildProfile(profile) {
+	const out = {
+		Name: profile.name,
+		DeviceType: profile.deviceType
+	};
+	addIf(out, "AutoInstall", profile.autoInstall);
+	addIf(out, "DontAutoSwitchWhenInstalled", profile.dontAutoSwitchWhenInstalled);
+	addIf(out, "Readonly", profile.readonly);
+	return out;
+}
+/**
+* Build the full manifest JSON object from a ManifestConfig.
+*
+* Applies all auto-derivation defaults and transforms camelCase
+* to the PascalCase format expected by the Elgato schema.
+*
+* @param config - The manifest configuration
+* @param codePath - Override CodePath (typically derived from bundler output)
+*/
+function buildManifestJson(config, codePath) {
+	const osEntries = config.os ? config.os.filter((o) => o != null) : DEFAULT_OS;
+	const nodejs = config.nodejs ?? { version: "24" };
+	const out = {
+		$schema: "https://schemas.elgato.com/streamdeck/plugins/manifest.json",
+		UUID: config.uuid,
+		Name: config.name,
+		Author: config.author,
+		Description: config.description,
+		Icon: config.icon,
+		Version: config.version,
+		CodePath: codePath ?? config.codePath ?? "bin/plugin.mjs",
+		OS: buildOS(osEntries),
+		Nodejs: buildNodejs(nodejs),
+		SDKVersion: config.sdkVersion ?? 2,
+		Software: { MinimumVersion: config.software?.minimumVersion ?? "7.1" },
+		Category: config.category ?? config.name,
+		CategoryIcon: config.categoryIcon ?? config.icon,
+		Actions: config.actions.map(buildAction)
+	};
+	addIf(out, "URL", config.url);
+	addIf(out, "SupportURL", config.supportUrl);
+	addIf(out, "PropertyInspectorPath", config.propertyInspectorPath);
+	addIf(out, "DefaultWindowSize", config.defaultWindowSize);
+	addIf(out, "CodePathMac", config.codePathMac);
+	addIf(out, "CodePathWin", config.codePathWin);
+	if (config.applicationsToMonitor) out["ApplicationsToMonitor"] = config.applicationsToMonitor;
+	if (config.profiles?.length) out["Profiles"] = config.profiles.map(buildProfile);
+	return out;
+}
+/**
+* Generate the full manifest JSON string from a ManifestConfig.
+*
+* @param config - The manifest configuration
+* @param codePath - Override CodePath (typically derived from bundler output)
+* @returns Formatted JSON string
+*/
+function generateManifestJsonString(config, codePath) {
+	const json = buildManifestJson(config, codePath);
+	return JSON.stringify(json, null, 2) + "\n";
+}
+/**
+* Write manifest.json only when the content has changed.
+* Creates the parent directory if it does not exist.
+*
+* @returns `true` if the file was written, `false` if content was unchanged.
+*/
+function writeManifestIfChanged(outPath, content) {
+	if (existsSync(outPath)) {
+		if (readFileSync(outPath, "utf-8") === content) return false;
+	}
+	const dir = dirname(outPath);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(outPath, content);
+	return true;
+}
+//#endregion
+export { generateManifestJsonString, validateManifestConfig, validatePluginUUID, writeManifestIfChanged };