@pipelab/plugin-construct 1.0.0-beta.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @pipelab/plugin-construct
+
+## 1.0.0-beta.0
+
+### Major Changes
+
+- e1befbf: initial release
+
+### Patch Changes
+
+- Updated dependencies [e1befbf]
+  - @pipelab/plugin-core@1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 CynToolkit
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @pipelab/plugin-construct
+
+Pipelab plugin for automating Construct 3 project exports.

package/dist/index.cjs

@@ -0,0 +1,433 @@
+Object.create;
+Object.defineProperty;
+Object.getOwnPropertyDescriptor;
+Object.getOwnPropertyNames;
+Object.getPrototypeOf;
+Object.prototype.hasOwnProperty;
+//#endregion
+let _pipelab_plugin_core = require("@pipelab/plugin-core");
+let node_path = require("node:path");
+require("valibot");
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let node_module = require("node:module");
+//#region src/assets/script.ts
+const registerInstallButtonListener = (page, log) => {
+	const installBtn = page.locator("#addonConfirmInstallDialog").locator(".okButton");
+	installBtn.waitFor({ timeout: 0 }).then(async () => {
+		await installBtn.click();
+		log("installBtn clicked");
+		registerInstallButtonListener(page, log);
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("installBtn.click() failed", e.message);
+	});
+};
+const registerSaveLoginExpiredistener = (page, log) => {
+	const cancelBtn = page.locator("#confirmDialog").locator(".cancelConfirmButton");
+	cancelBtn.waitFor({ timeout: 0 }).then(async () => {
+		await cancelBtn.click();
+		log("cancelBtn clicked");
+		registerSaveLoginExpiredistener(page, log);
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("cancelBtn.click() failed", e.message);
+	});
+};
+const registerWebglErrorListener = (page, log) => {
+	const okDialog = page.locator("#okDialog");
+	const webglErrorButton = okDialog.locator(".okButton");
+	webglErrorButton.waitFor({ timeout: 0 }).then(async () => {
+		if ((await okDialog.allInnerTexts()).join().toLowerCase().includes("webgl")) {
+			await webglErrorButton.click();
+			log("webglErrorButton clicked");
+			registerWebglErrorListener(page, log);
+		}
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("webglErrorButton.click() failed", e.message);
+	});
+};
+const registerDeprecatedFeatures = (page, log) => {
+	const okButton = page.locator("#deprecatedFeaturesDialog").locator(".okButton");
+	okButton.waitFor({ timeout: 0 }).then(async () => {
+		await okButton.click();
+		log("okButton clicked");
+		registerDeprecatedFeatures(page, log);
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("deprecatedFeatures.okButton.click() failed", e.message);
+	});
+};
+const registerWelcomeToConstructListener = (page, log) => {
+	const okButton = page.locator("#welcomeTourDialog").locator(".noThanksLink");
+	okButton.waitFor({ timeout: 0 }).then(async () => {
+		await okButton.click();
+		log("okButton clicked");
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("welcomeTour.okButton.click() failed", e.message);
+	});
+};
+const registerMissingAddonErrorListener = (page, log) => {
+	page.locator("#missingAddonsDialog").locator(".okButton").waitFor({ timeout: 0 }).then(async () => {
+		throw new Error("Missing addon. You should bundle addons with your project");
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("missingAddon.okButton.waitFor() failed", e.message);
+	});
+};
+const registerNewVersionAvailableListener = (page, log) => {
+	const cancelButton = page.locator("#confirmDialog").locator(".cancelConfirmButton");
+	cancelButton.waitFor({ timeout: 0 }).then(async () => {
+		await cancelButton.click();
+		log("cancelButton clicked");
+		registerNewVersionAvailableListener(page, log);
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("cancelButton.click() failed", e.message);
+	});
+};
+const script = async (page, log, filePath, username, password, version, downloadDir) => {
+	let url = "https://editor.construct.net/";
+	if (version) url += version;
+	log("Navigating to URL", url);
+	await page.goto(url);
+	log("after navigating");
+	registerWelcomeToConstructListener(page, log);
+	registerNewVersionAvailableListener(page, log);
+	log("after event");
+	await page.waitForTimeout(2e3);
+	log("after wait");
+	if (username && password) {
+		log("Authenticating");
+		await page.getByTitle("User account").locator("ui-icon").click();
+		await page.getByRole("menuitem", { name: "Log in" }).locator("span").click();
+		await page.frameLocator("#loginDialog iframe").getByLabel("Username").fill(username);
+		await page.frameLocator("#loginDialog iframe").getByLabel("Password").fill(password);
+		const tokenPromise = page.waitForResponse(/https:\/\/account.*\.construct\.net\/login.json/i);
+		await page.frameLocator("#loginDialog iframe").getByRole("button", { name: "Log in" }).click();
+		if ((await (await tokenPromise).json()).request.status === "error") {
+			await page.close();
+			throw new Error("Invalid credentials");
+		}
+		log("Authenticated");
+	}
+	await page.waitForTimeout(2e3);
+	const [fileChooser] = await Promise.all([page.waitForEvent("filechooser"), page.keyboard.press("ControlOrMeta+O")]);
+	log("filechooser");
+	console.log("filePath", filePath);
+	await fileChooser.setFiles([filePath]);
+	log("Set file");
+	const progressDialog = page.locator("#progressDialog");
+	const progessBar = progressDialog.locator(".progressBar");
+	log("Waiting for progress dialog");
+	await progressDialog.waitFor({ timeout: 0 });
+	log("Got loading progress dialog");
+	const progressInterval = setInterval(async () => {
+		const text = await progessBar.getAttribute("value");
+		const textAsNumber = parseFloat(text);
+		log("progress", `${(Number.isNaN(textAsNumber) ? 0 : textAsNumber) * 100}%`);
+	}, 500);
+	const notNowBtn = page.getByText("Not now");
+	notNowBtn.waitFor({ timeout: 0 }).then(async () => {
+		return notNowBtn.click();
+	}).then(() => {
+		log("notNowBtn clicked");
+	}).catch(async (e) => {
+		if (e.message.includes("Target page, context or browser has been closed")) return;
+		log("notNowBtn.click() failed", e.message);
+	});
+	registerInstallButtonListener(page, log);
+	registerWebglErrorListener(page, log);
+	registerMissingAddonErrorListener(page, log);
+	registerDeprecatedFeatures(page, log);
+	registerSaveLoginExpiredistener(page, log);
+	log("Waiting for progress dialog to disapear");
+	await progressDialog.waitFor({
+		state: "detached",
+		timeout: 0
+	});
+	log("Got progress dialog to disapear");
+	clearTimeout(progressInterval);
+	await page.getByRole("button", { name: "Menu" }).click();
+	await page.getByRole("menuitem", { name: "Project" }).click();
+	await page.getByRole("menuitem", { name: "Export" }).click();
+	log("\"Export\" clicked");
+	await page.locator("ui-iconviewitem").filter({ hasText: "Web (HTML5)" }).locator("ui-icon").click();
+	log("\"Web\" clicked");
+	await page.locator("#exportSelectPlatformDialog").getByRole("button", { name: "Next" }).click();
+	await page.getByLabel("Offline support").uncheck();
+	log("Disabled offline support");
+	await page.locator("#exportStandardOptionsDialog").getByRole("button", { name: "Next" }).click();
+	log("\"Next\" clicked");
+	const downloadPromise = page.waitForEvent("download");
+	await page.locator(".downloadExportedProject").click();
+	const download = await downloadPromise;
+	await page.getByRole("button", { name: "OK" }).click();
+	log("\"Download\" clicked");
+	const finalPath = (0, node_path.join)(downloadDir, download.suggestedFilename());
+	await download.saveAs(finalPath);
+	log("File Downloaded");
+	await page.close();
+	return finalPath;
+};
+//#endregion
+//#region src/export-shared.ts
+const platform = process.platform;
+const { LOCALAPPDATA, XDG_CONFIG_HOME } = process.env;
+const isCI = process.env.CI === "true";
+let baseProfile;
+if (platform === "win32") baseProfile = (0, node_path.join)(LOCALAPPDATA ?? "", "Google", "Chrome", "User Data");
+else if (platform === "linux") baseProfile = (0, node_path.join)(XDG_CONFIG_HOME ?? "", "google-chrome");
+else if (platform === "darwin") baseProfile = (0, node_path.join)((0, node_os.homedir)(), "Library", "Application Support", "Google", "Chrome");
+const sharedParams = {
+	username: (0, _pipelab_plugin_core.createStringParam)("", {
+		label: "Username",
+		required: false,
+		description: "Your Construct username"
+	}),
+	password: (0, _pipelab_plugin_core.createPasswordParam)("", {
+		description: "Your Construct password. Will only be used locally to automate the export on Construct website via a local browser. Will not be sent to any server.",
+		required: false,
+		label: "Password"
+	}),
+	version: (0, _pipelab_plugin_core.createStringParam)("", {
+		description: "The Construct version you want to use",
+		label: "Version",
+		required: false
+	}),
+	headless: {
+		description: "Whether to show the browser while export",
+		required: false,
+		control: { type: "boolean" },
+		value: false,
+		label: "Start headless"
+	},
+	timeout: (0, _pipelab_plugin_core.createNumberParam)(120, {
+		description: "The timeout (in seconds) to close the browser if it's stuck",
+		required: false,
+		label: "Timeout"
+	}),
+	customProfile: (0, _pipelab_plugin_core.createPathParam)(void 0, {
+		required: false,
+		description: "Use your own profile (X:\\Users\\XXX\\AppData\\Local\\Google\\Chrome\\User Data). Usefull if you want to reuse plugins installed in your current browser",
+		control: {
+			type: "path",
+			options: {
+				properties: ["openDirectory"],
+				defaultPath: baseProfile
+			}
+		},
+		label: "Custom profile"
+	})
+};
+const exportc3p = async (file, { cwd, log, inputs, setOutput, paths, abortSignal, context: ctx }) => {
+	let browserContext = void 0;
+	let browser = void 0;
+	abortSignal.addEventListener("abort", () => {
+		console.error("aborted");
+		browserContext?.close();
+	});
+	const newInputs = inputs;
+	const { thirdparty, node, pnpm } = paths;
+	const browserName = "chromium";
+	const { packageDir: playwrightPkgPath } = await (0, _pipelab_plugin_core.fetchPackage)("playwright-core", "1.48.2", {
+		installDeps: true,
+		context: ctx
+	});
+	const playwrightCli = (0, node_path.join)(playwrightPkgPath, "cli.js");
+	const browsersPath = (0, node_path.join)(thirdparty, "playwright-browsers");
+	process.env.PLAYWRIGHT_BROWSERS_PATH = browsersPath;
+	log("Downloading browser to", browsersPath);
+	await (0, _pipelab_plugin_core.runWithLiveLogs)(node, [
+		playwrightCli,
+		"install",
+		browserName
+	], {
+		env: {
+			...process.env,
+			PLAYWRIGHT_BROWSERS_PATH: browsersPath,
+			PATH: `${(0, node_path.dirname)(node)}${node_path.delimiter}${process.env.PATH}`
+		},
+		cancelSignal: abortSignal
+	}, log, {
+		onStdout(data) {
+			log(data);
+		},
+		onStderr(data) {
+			log(data);
+		}
+	});
+	const playwrightModule = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)((0, node_path.join)(playwrightPkgPath, "index.js"));
+	const playwright = playwrightModule.default || playwrightModule;
+	const downloadDir = (0, node_path.join)(cwd, "playwright");
+	log("Browser downloaded to", downloadDir);
+	log("Exporting construct project");
+	console.log("newInputs", newInputs);
+	const browserInstance = playwright[browserName];
+	let version = newInputs.version;
+	if (version && /^\d+$/.test(version)) version = `r${version}`;
+	const headless = newInputs.headless;
+	if (newInputs.customProfile) {
+		const customProfile = (0, node_path.join)(cwd, "playwright-profile");
+		await (0, node_fs_promises.mkdir)(customProfile, { recursive: true });
+		const indexedDbPathSource = (0, node_path.join)(newInputs.customProfile, "Default", "IndexedDB");
+		const indexedDbPathDestination = (0, node_path.join)(customProfile, "Default", "IndexedDB");
+		for (const p of ["https_editor.construct.net_0.indexeddb.blob", "https_editor.construct.net_0.indexeddb.leveldb"]) await (0, node_fs_promises.cp)((0, node_path.join)(indexedDbPathSource, p), (0, node_path.join)(indexedDbPathDestination, p), { recursive: true });
+		browserContext = await browserInstance.launchPersistentContext(customProfile, {
+			headless,
+			locale: "en-US",
+			recordVideo: isCI ? { dir: (0, node_path.join)(process.cwd(), "playwright") } : void 0
+		});
+	} else {
+		browser = await browserInstance.launch({ headless });
+		browserContext = await browser.newContext({
+			locale: "en-US",
+			recordVideo: isCI ? { dir: (0, node_path.join)(process.cwd(), "playwright") } : void 0
+		});
+		await browserContext?.clearPermissions();
+	}
+	if (!browserContext) throw new Error("Failed to initialize browser context");
+	const page = await browserContext.newPage();
+	page.setDefaultTimeout(newInputs.timeout * 1e3);
+	await page.addInitScript(() => {
+		delete self.showOpenFilePicker;
+	});
+	page.on("filechooser", (worker) => {
+		console.log("filechooser created: " + worker.page.name);
+	});
+	try {
+		const result = await script(page, log, file, newInputs.username, newInputs.password, version, downloadDir);
+		log("Setting output result to ", result);
+		setOutput("folder", result);
+		setOutput("parentFolder", (0, node_path.dirname)(result));
+		setOutput("zipFile", result);
+	} catch (e) {
+		log("error, no result, crashed", e);
+		throw new Error("ConstructExport failed: " + e.message);
+	} finally {
+		if (browserContext) await browserContext.close();
+		if (browser) await browser.close();
+	}
+};
+const exportAction = (0, _pipelab_plugin_core.createAction)({
+	id: "export-construct-project",
+	name: "Export .c3p",
+	displayString: "`Export project ${fmt.param(params.file, 'primary', 'No path selected')} with version ${params.version ? params.version : 'stable'}`",
+	meta: {},
+	params: {
+		file: (0, _pipelab_plugin_core.createPathParam)("", {
+			label: "File (.c3p)",
+			required: true,
+			control: {
+				type: "path",
+				label: "Pick a file (.c3p)",
+				options: {
+					properties: ["openFile"],
+					filters: [{
+						name: "Construct Project",
+						extensions: ["c3p"]
+					}],
+					title: "aaaa",
+					message: "bbbb"
+				}
+			}
+		}),
+		...sharedParams
+	},
+	outputs: {
+		folder: {
+			type: "path",
+			deprecated: true,
+			value: void 0,
+			label: "Exported zip"
+		},
+		parentFolder: {
+			type: "path",
+			deprecated: false,
+			value: void 0,
+			label: "Path to parent folder of exported zip"
+		},
+		zipFile: {
+			type: "path",
+			deprecated: false,
+			value: void 0,
+			label: "Exported zip"
+		}
+	},
+	description: "Export construct project from .c3p file",
+	icon: ""
+});
+const ExportActionRunner = (0, _pipelab_plugin_core.createActionRunner)(async (options) => {
+	const file = options.inputs.file;
+	if (!await (0, _pipelab_plugin_core.fileExists)(file)) throw new Error("You must specify a valid .c3p file");
+	await exportc3p(file, options);
+	options.log("exportc3p done");
+});
+const exportProjectAction = (0, _pipelab_plugin_core.createAction)({
+	id: "export-construct-project-folder",
+	name: "Export folder",
+	displayString: "`Export project ${params.version ? `r${params.version}` : ''}`",
+	meta: {},
+	params: {
+		folder: (0, _pipelab_plugin_core.createPathParam)("", {
+			required: true,
+			label: "Folder",
+			control: {
+				type: "path",
+				options: { properties: ["openDirectory"] }
+			}
+		}),
+		...sharedParams
+	},
+	outputs: {
+		folder: {
+			type: "path",
+			deprecated: true,
+			value: void 0,
+			label: "Exported zip"
+		},
+		parentFolder: {
+			type: "path",
+			deprecated: false,
+			value: void 0,
+			label: "Path to parent folder of exported zip"
+		},
+		zipFile: {
+			type: "path",
+			deprecated: false,
+			value: void 0,
+			label: "Exported zip"
+		}
+	},
+	description: "Export construct project from folder",
+	icon: ""
+});
+const ExportProjectActionRunner = (0, _pipelab_plugin_core.createActionRunner)(async (options) => {
+	if (!await (0, _pipelab_plugin_core.fileExists)(options.inputs.folder)) throw new Error("You must specify a valid construct project folder");
+	const outputPath = (0, node_path.join)(options.cwd, "c3_tmp_proj.c3p");
+	await exportc3p(await (0, _pipelab_plugin_core.zipFolder)(options.inputs.folder, outputPath, options.log), options);
+});
+//#endregion
+//#region src/index.ts
+const icon = new URL("./assets/construct.webp", require("url").pathToFileURL(__filename).href).href;
+var src_default = (0, _pipelab_plugin_core.createNodeDefinition)({
+	description: "Construct",
+	name: "Construct",
+	id: "construct",
+	icon: {
+		type: "image",
+		image: icon
+	},
+	nodes: [{
+		node: exportAction,
+		runner: ExportActionRunner
+	}, {
+		node: exportProjectAction,
+		runner: ExportProjectActionRunner
+	}],
+	validators: []
+});
+//#endregion
+module.exports = src_default;

package/dist/index.d.cts

@@ -0,0 +1,132 @@
+import { ExtractInputsFromAction } from "@pipelab/plugin-core";
+
+//#region src/export-c3p.d.ts
+declare const exportAction: {
+  id: string;
+  name: string;
+  displayString: string;
+  meta: {};
+  params: {
+    username: {
+      control: {
+        type: "input";
+        options: {
+          kind: "text";
+        };
+      };
+      value: string;
+      description?: string | undefined;
+      platforms?: NodeJS.Platform[] | undefined;
+      label: string;
+      validator?: (() => any) | undefined;
+      required: boolean;
+      onNodeUpdate?: ((value: any, settings: undefined<any>) => void) | undefined;
+    };
+    password: {
+      control: {
+        type: "input";
+        options: {
+          kind: "text";
+          password: true;
+        };
+      };
+      value: string;
+      description?: string | undefined;
+      platforms?: NodeJS.Platform[] | undefined;
+      label: string;
+      validator?: (() => any) | undefined;
+      required: boolean;
+      onNodeUpdate?: ((value: any, settings: undefined<any>) => void) | undefined;
+    };
+    version: {
+      control: {
+        type: "input";
+        options: {
+          kind: "text";
+        };
+      };
+      value: string;
+      description?: string | undefined;
+      platforms?: NodeJS.Platform[] | undefined;
+      label: string;
+      validator?: (() => any) | undefined;
+      required: boolean;
+      onNodeUpdate?: ((value: any, settings: undefined<any>) => void) | undefined;
+    };
+    headless: {
+      description: string;
+      required: false;
+      control: {
+        type: "boolean";
+      };
+      value: boolean;
+      label: string;
+    };
+    timeout: {
+      control: {
+        type: "input";
+        options: {
+          kind: "number";
+        };
+      };
+      value: number;
+      description?: string | undefined;
+      platforms?: NodeJS.Platform[] | undefined;
+      label: string;
+      validator?: (() => any) | undefined;
+      required: boolean;
+      onNodeUpdate?: ((value: any, settings: undefined<any>) => void) | undefined;
+    };
+    customProfile: {
+      value: string | undefined;
+      description?: string | undefined;
+      platforms?: NodeJS.Platform[] | undefined;
+      label: string;
+      validator?: (() => any) | undefined;
+      required: boolean;
+      control: undefined;
+      onNodeUpdate?: ((value: any, settings: undefined<any>) => void) | undefined;
+    };
+    file: {
+      value: string | undefined;
+      description?: string | undefined;
+      platforms?: NodeJS.Platform[] | undefined;
+      label: string;
+      validator?: (() => any) | undefined;
+      required: boolean;
+      control: undefined;
+      onNodeUpdate?: ((value: any, settings: undefined<any>) => void) | undefined;
+    };
+  };
+  outputs: {
+    folder: {
+      type: string;
+      deprecated: true;
+      value: undefined | string;
+      label: string;
+    };
+    parentFolder: {
+      type: string;
+      deprecated: false;
+      value: undefined | string;
+      label: string;
+    };
+    zipFile: {
+      type: string;
+      deprecated: false;
+      value: undefined | string;
+      label: string;
+    };
+  };
+  description: string;
+  icon: string;
+} & {
+  type: "action";
+};
+type Params = ExtractInputsFromAction<typeof exportAction>;
+//#endregion
+//#region src/index.d.ts
+declare const _default: undefined;
+//#endregion
+export { type Params as ExportParams, _default as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/export-c3p.ts","../src/index.ts"],"mappings":";;;cAWa,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+DD,MAAA,GAAS,uBAAA,QAA+B,YAAA"}