@kizenapps/packager 0.1.0

package/dist/index.js

@@ -0,0 +1,749 @@
+// src/lib/minify.ts
+var minifyFile = async (file) => {
+  if (file.path.endsWith(".js")) {
+    if (!file.content) {
+      return "";
+    }
+    const { minify } = await import("@node-minify/core");
+    const { uglifyJs } = await import("@node-minify/uglify-js");
+    const result = await minify({
+      compressor: uglifyJs,
+      content: file.content,
+      options: {
+        mangle: true,
+        parse: {
+          bare_returns: true
+        }
+      }
+    });
+    return result;
+  }
+  return file.content;
+};
+var minifyFiles = async (files) => {
+  return Promise.all(
+    files.map(async (file) => {
+      const minified = await minifyFile(file);
+      return { ...file, minified };
+    })
+  );
+};
+
+// src/lib/apiNames.ts
+var sanitizeToAPIName = (name) => {
+  return name.toLowerCase().replace(/[^a-z0-9\-\s]/g, "").replace(/\s+/g, "_");
+};
+var scriptRuntimeToApiName = (runtime) => {
+  const result = runtime.replace(/\s+/g, "-").replace(/\./g, "-");
+  return result;
+};
+
+// src/lib/image.ts
+var imagetoUint8Array = (base64Image) => {
+  const byteCharacters = atob(base64Image);
+  const byteNumbers = new Array(byteCharacters.length);
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  return new Uint8Array(byteNumbers);
+};
+var zipToUint8Array = (zip) => {
+  return Uint8Array.from(zip);
+};
+
+// src/lib/structure.ts
+var thumbnailImageExtensions = ["png"];
+var triggerImageExtensions = [...thumbnailImageExtensions, "svg"];
+var EVENT_SCRIPTS_DIRECTORY_NAME = "eventScripts";
+var FLOATING_FRAMES_DIRECTORY_NAME = "floatingFrames";
+var DATA_ADORNMENTS_DIRECTORY_NAME = "dataAdornments";
+var TOOLBAR_ITEMS_DIRECTORY_NAME = "toolbarItems";
+var ROUTABLE_PAGES_DIRECTORY_NAME = "pages";
+var BROWSER_ROUTE_SCRIPTS_DIRECTORY_NAME = "routeScripts";
+var JS_ACTIONS_DIRECTORY_NAME = "actions";
+var OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME = "objectSettingsItems";
+var AUTOMATION_STEPS_DIRECTORY_NAME = "automationSteps";
+var SETUP_ASSISTANT_DIRECTORY_NAME = "setupAssistant";
+var USER_SETUP_ASSISTANT_DIRECTORY_NAME = "userSetupAssistant";
+var CALENDAR_SOURCES_DIRECTORY_NAME = "calendarSources";
+var THUMBNAIL_FILE_NAMES = thumbnailImageExtensions.map(
+  (ext) => `thumbnail.${ext}`
+);
+var RELEASE_NOTES_EXTENSION = "md";
+var SCRIPT_EXTENSION = "js";
+var MAIN_SCRIPT_FILE = `script.${SCRIPT_EXTENSION}`;
+var MESSAGE_SCRIPT_FILE = `message.${SCRIPT_EXTENSION}`;
+var CALLBACK_SCRIPT_FILE = `callback.${SCRIPT_EXTENSION}`;
+var AUTOMATION_SCRIPT_FILE = `script.py`;
+var CONFIG_FILE_NAME = "config.json";
+var STYLES_FILE_NAME = "styles.css";
+var MANIFEST_FILE_NAME = "kizen.json";
+var KZN_FILE_NAME = "import.kzn";
+var maybeParseConfig = (content, path) => {
+  if (!content) {
+    throw new Error(`No content provided for config file: ${path}`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Failed to parse config content: ${path}`);
+  }
+};
+var getMinimizedConfig = (config, entry, splitPath, consideredFiles) => {
+  const result = config["minimized_config"] ?? {};
+  if (result["customIconFile"]) {
+    let basePath = splitPath.slice(0, -1).join("/");
+    if (entry.endsWith("/")) {
+      basePath = `${entry}${basePath}`;
+    } else {
+      basePath = `${entry}/${basePath}`;
+    }
+    const filePath = `${basePath}/${result["customIconFile"]}`;
+    const file = consideredFiles.find((f) => f.path === filePath);
+    if (file?.base64Image) {
+      let extension = filePath.split(".").pop()?.toLowerCase();
+      if (extension === "svg") {
+        extension = "svg+xml";
+      }
+      result["customIcon"] = `data:image/${extension};base64,${file.base64Image}`;
+    }
+  }
+  return result;
+};
+var getAdornmentIcon = (config, entry, splitPath, consideredFiles) => {
+  if (config["customIconFile"]) {
+    let basePath = splitPath.slice(0, -1).join("/");
+    if (entry.endsWith("/")) {
+      basePath = `${entry}${basePath}`;
+    } else {
+      basePath = `${entry}/${basePath}`;
+    }
+    const filePath = `${basePath}/${config["customIconFile"]}`;
+    const file = consideredFiles.find((f) => f.path === filePath);
+    if (file?.base64Image) {
+      let extension = filePath.split(".").pop()?.toLowerCase();
+      if (extension === "svg") {
+        extension = "svg+xml";
+      }
+      return `data:image/${extension};base64,${file.base64Image}`;
+    }
+  }
+  return "";
+};
+
+// src/lib/package.ts
+var replacementVar = "__kizen_state";
+var prepend = "const __kizen_utils = {};\n";
+var convertToSelfInvokingFunction = (fn, variable, args = {}, prependCode = "") => {
+  const functionString = fn.replace(/\n$/, "").replace(/;$/, "");
+  const inner = `(${functionString})({ state: {{${variable}}}, args: ${JSON.stringify(args)}, utils: __kizen_utils })`;
+  const full = `(function() { ${prependCode}
+return ${inner}; })()`;
+  return full;
+};
+var mapFields = (fields, scriptsByKey) => {
+  return fields.map((field) => {
+    if (field["type"] === "container" && field["fields"] && Array.isArray(field["fields"])) {
+      return {
+        ...field,
+        fields: mapFields(
+          field["fields"],
+          scriptsByKey
+        )
+      };
+    }
+    const fieldKey = field["key"];
+    const scripts = scriptsByKey[fieldKey];
+    if (scripts) {
+      const result = { ...field };
+      for (const fnName of [
+        "getFetchUrl",
+        "optionMapper",
+        "getHeaders",
+        "getBody",
+        "getContextUrl"
+      ]) {
+        const fn = scripts[fnName];
+        if (fn) {
+          result[fnName] = convertToSelfInvokingFunction(
+            fn,
+            replacementVar,
+            {},
+            prepend
+          );
+        }
+      }
+      return result;
+    }
+    return field;
+  });
+};
+var processSetupAssistantFromFiles = (assistantConfig, scripts) => {
+  if (!assistantConfig) {
+    return void 0;
+  }
+  const scriptsByKey = scripts.reduce(
+    (acc, script) => {
+      if (!acc[script.key]) {
+        acc[script.key] = {};
+      }
+      acc[script.key][script.type] = script.content;
+      return acc;
+    },
+    {}
+  );
+  const newConfig = { ...assistantConfig };
+  if (newConfig["fields"] && Array.isArray(newConfig["fields"])) {
+    newConfig["fields"] = mapFields(
+      newConfig["fields"],
+      scriptsByKey
+    );
+  }
+  return newConfig;
+};
+var processOnePluginFromManifest = (manifest, files) => {
+  const entry = manifest.entry;
+  const releaseNotesDirectory = manifest.release_notes_directory;
+  const apiName = manifest.api_name;
+  const consideredFiles = files.filter(
+    (f) => f.path !== MANIFEST_FILE_NAME && f.path.startsWith(entry)
+  );
+  const releaseNotesFiles = releaseNotesDirectory ? files.filter((f) => f.path.startsWith(releaseNotesDirectory)) : [];
+  const { version } = manifest;
+  const releaseNotes = releaseNotesFiles.find(
+    (file) => file.path.endsWith(`${version}.${RELEASE_NOTES_EXTENSION}`)
+  );
+  const floatingFrames = {};
+  const dataAdornments = {};
+  const toolbarItems = {};
+  const routablePages = {};
+  const routeScripts = {};
+  const jsActions = {};
+  const objectSettingsItems = {};
+  const automationSteps = {};
+  const calendarSources = {};
+  let thumbnail = null;
+  let kznFile = null;
+  let hasBlockingCondition = false;
+  const requiredConfigFiles = {};
+  let setupAssistantJSON = null;
+  const setupAssistantFunctions = [];
+  let userSetupAssistantJSON = null;
+  const userSetupAssistantFunctions = [];
+  for (const file of consideredFiles) {
+    let strippedPath = file.path.replace(entry, "");
+    strippedPath = strippedPath.startsWith("/") ? strippedPath.substring(1) : strippedPath;
+    const splitPath = strippedPath.split("/");
+    if (splitPath[0] === SETUP_ASSISTANT_DIRECTORY_NAME) {
+      if (splitPath[1] === "assistant.json") {
+        setupAssistantJSON = maybeParseConfig(file.content, file.path);
+      } else {
+        const assistantKey = splitPath[1];
+        if (assistantKey && splitPath[2]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
+          setupAssistantFunctions.push({
+            key: assistantKey,
+            type: splitPath[2].replace(`.${SCRIPT_EXTENSION}`, ""),
+            content: file.content
+          });
+        }
+      }
+    } else if (splitPath[0] === USER_SETUP_ASSISTANT_DIRECTORY_NAME) {
+      if (splitPath[1] === "assistant.json") {
+        userSetupAssistantJSON = maybeParseConfig(file.content, file.path);
+      } else {
+        const assistantKey = splitPath[1];
+        if (assistantKey && splitPath[2]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
+          userSetupAssistantFunctions.push({
+            key: assistantKey,
+            type: splitPath[2].replace(`.${SCRIPT_EXTENSION}`, ""),
+            content: file.content
+          });
+        }
+      }
+    } else if (splitPath[0] === FLOATING_FRAMES_DIRECTORY_NAME) {
+      const floatingFrameName = splitPath[1];
+      if (!floatingFrameName) continue;
+      if (!floatingFrames[floatingFrameName]) {
+        requiredConfigFiles[`frame:${floatingFrameName}`] = true;
+        floatingFrames[floatingFrameName] = {
+          name: "",
+          api_name: "",
+          title: "",
+          type: "script",
+          css: "",
+          event_scripts: {},
+          default_position: "bottom-right",
+          header_color: "",
+          header_text_color: "",
+          height: 0,
+          width: 0,
+          ignore: [],
+          match: [],
+          message_handler: "",
+          minimized_style: "circle",
+          minimized_config: {},
+          script: "",
+          html: "",
+          when: ""
+        };
+      }
+      const frame = floatingFrames[floatingFrameName];
+      if (splitPath[2] === EVENT_SCRIPTS_DIRECTORY_NAME) {
+        if (splitPath[3]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
+          const functionName = splitPath[3].replace(`.${SCRIPT_EXTENSION}`, "");
+          frame.event_scripts[functionName] = file.minified;
+        }
+      } else if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`frame:${floatingFrameName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        frame.name = config["name"] || "";
+        frame.api_name = config["api_name"] || sanitizeToAPIName(floatingFrameName);
+        frame.title = config["title"] || "";
+        frame.default_position = config["default_position"] || "bottom-right";
+        frame.header_color = config["header_color"] || "";
+        frame.header_text_color = config["header_text_color"] || "";
+        frame.height = config["height"] || 0;
+        frame.width = config["width"] || 0;
+        frame.ignore = config["ignore"] || [];
+        frame.match = config["match"] || [];
+        frame.html = config["html"] || "";
+        frame.minimized_style = config["minimized_style"] || "circle";
+        frame.minimized_config = getMinimizedConfig(
+          config,
+          entry,
+          splitPath,
+          consideredFiles
+        );
+        frame.when = config["when"] || "";
+      } else if (splitPath[2] === MESSAGE_SCRIPT_FILE) {
+        frame.message_handler = file.minified;
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        frame.script = file.minified;
+      } else if (splitPath[2] === STYLES_FILE_NAME) {
+        frame.css = file.minified;
+      }
+    } else if (splitPath[0] === DATA_ADORNMENTS_DIRECTORY_NAME) {
+      const dataAdornmentName = splitPath[1];
+      if (!dataAdornmentName) continue;
+      if (!dataAdornments[dataAdornmentName]) {
+        requiredConfigFiles[`dataAdornment:${dataAdornmentName}`] = true;
+        dataAdornments[dataAdornmentName] = {
+          config: { icon: "", color: "", tooltip: "" },
+          field_type: "phonenumber",
+          script: "",
+          when: ""
+        };
+      }
+      const adornment = dataAdornments[dataAdornmentName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`dataAdornment:${dataAdornmentName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        adornment.config.icon = config["icon"] || "";
+        adornment.config.color = config["color"] || "";
+        adornment.config.tooltip = config["tooltip"] || "";
+        adornment.config.customIcon = getAdornmentIcon(
+          config,
+          entry,
+          splitPath,
+          consideredFiles
+        );
+        adornment.field_type = config["field_type"] || "phonenumber";
+        adornment.when = config["when"] || "";
+        if (config["when"]) hasBlockingCondition = true;
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        adornment.script = file.minified;
+      }
+    } else if (splitPath[0] === TOOLBAR_ITEMS_DIRECTORY_NAME) {
+      const toolbarItemName = splitPath[1];
+      if (!toolbarItemName) continue;
+      if (!toolbarItems[toolbarItemName]) {
+        requiredConfigFiles[`toolbarItem:${toolbarItemName}`] = true;
+        toolbarItems[toolbarItemName] = {
+          api_name: "",
+          label: "",
+          icon: "",
+          color: "",
+          script: "",
+          when: ""
+        };
+      }
+      const item = toolbarItems[toolbarItemName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`toolbarItem:${toolbarItemName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        item.api_name = config["api_name"] || sanitizeToAPIName(toolbarItemName);
+        item.label = config["label"] || "";
+        item.icon = config["icon"] || "";
+        item.color = config["color"] || "";
+        item.when = config["when"] || "";
+        if (config["when"]) hasBlockingCondition = true;
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        item.script = file.minified;
+      }
+    } else if (splitPath[0] === ROUTABLE_PAGES_DIRECTORY_NAME) {
+      const pageName = splitPath[1];
+      if (!pageName) continue;
+      if (!routablePages[pageName]) {
+        requiredConfigFiles[`page:${pageName}`] = true;
+        routablePages[pageName] = {
+          name: pageName,
+          api_name: "",
+          event_scripts: {},
+          script: "",
+          callback: "",
+          css: "",
+          is_toolbar_item: false,
+          toolbar_color: "",
+          toolbar_icon: "",
+          type: "script",
+          html: "",
+          iframe_url: ""
+        };
+      }
+      const page = routablePages[pageName];
+      if (splitPath[2] === EVENT_SCRIPTS_DIRECTORY_NAME) {
+        if (splitPath[3]?.endsWith(SCRIPT_EXTENSION)) {
+          const functionName = splitPath[3].replace(`.${SCRIPT_EXTENSION}`, "");
+          page.event_scripts[functionName] = file.minified;
+        }
+      } else if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`page:${pageName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        page.api_name = config["api_name"] || sanitizeToAPIName(pageName);
+        page.name = config["name"] || pageName;
+        page.is_toolbar_item = config["is_toolbar_item"] || false;
+        page.toolbar_color = config["toolbar_color"] || "";
+        page.toolbar_icon = config["toolbar_icon"] || "";
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        page.script = file.minified;
+      } else if (splitPath[2] === CALLBACK_SCRIPT_FILE) {
+        page.callback = file.minified;
+      } else if (splitPath[2] === STYLES_FILE_NAME) {
+        page.css = file.minified;
+      }
+    } else if (splitPath[0] === AUTOMATION_STEPS_DIRECTORY_NAME) {
+      const stepName = splitPath[1];
+      if (!stepName) continue;
+      if (!automationSteps[stepName]) {
+        requiredConfigFiles[`automationStep:${stepName}`] = true;
+        automationSteps[stepName] = {
+          name: "",
+          action_step_api_name: "",
+          overall_description: "",
+          action_description: "",
+          action_type: "",
+          script_runtime: scriptRuntimeToApiName("python 3.12"),
+          secrets: [],
+          inputs: [],
+          outputs: [],
+          script: "",
+          when: ""
+        };
+      }
+      const step = automationSteps[stepName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`automationStep:${stepName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        step.name = config["name"] || stepName;
+        step.action_step_api_name = config["api_name"] || sanitizeToAPIName(stepName);
+        step.overall_description = config["plugin_description"] || "";
+        step.action_description = config["action_description"] || "";
+        step.action_type = config["action_type"] || "";
+        step.secrets = config["secrets"] || [];
+        step.inputs = config["inputs"] || [];
+        step.outputs = config["outputs"] || [];
+        step.script_runtime = scriptRuntimeToApiName(
+          config["runtime"] || "python 3.12"
+        );
+        step.when = config["when"] || "";
+        if (config["when"]) hasBlockingCondition = true;
+      } else if (splitPath[2] === AUTOMATION_SCRIPT_FILE) {
+        step.script = file.content;
+      }
+    } else if (splitPath[0] === BROWSER_ROUTE_SCRIPTS_DIRECTORY_NAME) {
+      const routeName = splitPath[1];
+      if (!routeName) continue;
+      if (!routeScripts[routeName]) {
+        requiredConfigFiles[`route:${routeName}`] = true;
+        routeScripts[routeName] = {
+          script: "",
+          api_name: "",
+          hint_object_name: "",
+          routes: [],
+          name: routeName
+        };
+      }
+      const route = routeScripts[routeName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`route:${routeName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        route.api_name = config["api_name"] || sanitizeToAPIName(routeName);
+        route.hint_object_name = config["hint_object_name"] || "";
+        route.routes = config["routes"] || [];
+        route.name = config["name"] || routeName;
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        route.script = file.minified;
+      }
+    } else if (splitPath[0] === JS_ACTIONS_DIRECTORY_NAME) {
+      const actionName = splitPath[1];
+      if (!actionName) continue;
+      if (!jsActions[actionName]) {
+        requiredConfigFiles[`action:${actionName}`] = true;
+        jsActions[actionName] = {
+          script: "",
+          name: "",
+          hint_object_name: "",
+          api_name: ""
+        };
+      }
+      const action = jsActions[actionName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`action:${actionName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        action.name = config["name"] || actionName;
+        action.hint_object_name = config["hint_object_name"] || "";
+        action.api_name = config["api_name"] || sanitizeToAPIName(actionName);
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        action.script = file.minified;
+      }
+    } else if (splitPath[0] === OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME) {
+      const itemName = splitPath[1];
+      if (!itemName) continue;
+      if (!objectSettingsItems[itemName]) {
+        requiredConfigFiles[`objectSettingsItem:${itemName}`] = true;
+        objectSettingsItems[itemName] = {
+          api_name: "",
+          label: "",
+          script: "",
+          when: ""
+        };
+      }
+      const settingsItem = objectSettingsItems[itemName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`objectSettingsItem:${itemName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        settingsItem.api_name = config["api_name"] || sanitizeToAPIName(itemName);
+        settingsItem.label = config["label"] || "";
+        settingsItem.when = config["when"] || "";
+      } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
+        settingsItem.script = file.minified;
+      }
+    } else if (splitPath[0] === CALENDAR_SOURCES_DIRECTORY_NAME) {
+      const itemName = splitPath[1];
+      if (!itemName) continue;
+      if (!calendarSources[itemName]) {
+        requiredConfigFiles[`calendarSource:${itemName}`] = true;
+        calendarSources[itemName] = {
+          api_name: "",
+          name: "",
+          calendars_script: "",
+          events_script: "",
+          when: ""
+        };
+      }
+      const cal = calendarSources[itemName];
+      if (splitPath[2] === CONFIG_FILE_NAME) {
+        requiredConfigFiles[`calendarSource:${itemName}`] = false;
+        const config = maybeParseConfig(file.content, file.path);
+        cal.api_name = config["api_name"] || sanitizeToAPIName(itemName);
+        cal.name = config["name"] || "";
+        cal.when = config["when"] || "";
+        if (config["when"]) hasBlockingCondition = true;
+      } else if (splitPath[2] === "calendars.js") {
+        cal.calendars_script = file.minified;
+      } else if (splitPath[2] === "events.js") {
+        cal.events_script = file.minified;
+      }
+    } else if (splitPath[0] === KZN_FILE_NAME) {
+      if (!file.binaryData) {
+        throw new Error(
+          `KZN file ${file.path} does not contain binary data. Cannot proceed.`
+        );
+      }
+      if (kznFile) {
+        throw new Error(
+          `Multiple KZN files found for plugin ${apiName}. Only one is allowed.`
+        );
+      }
+      kznFile = zipToUint8Array(file.binaryData);
+    } else if (THUMBNAIL_FILE_NAMES.includes(splitPath[0] ?? "")) {
+      if (file.base64Image) {
+        if (thumbnail) {
+          throw new Error(
+            `Multiple thumbnail files found for plugin ${apiName}. Only one is allowed.`
+          );
+        }
+        thumbnail = imagetoUint8Array(file.base64Image);
+      }
+    }
+  }
+  const requiredFileKeys = Object.keys(requiredConfigFiles).filter(
+    (key) => requiredConfigFiles[key] === true
+  );
+  if (requiredFileKeys.length > 0) {
+    throw new Error(
+      `The following required files are missing for plugin ${apiName}: ${requiredFileKeys.join(" config.json, ")} config.json. Please ensure these files are present in the repository.`
+    );
+  }
+  const setupAssistantContent = processSetupAssistantFromFiles(
+    setupAssistantJSON,
+    setupAssistantFunctions
+  );
+  const userSetupAssistantContent = processSetupAssistantFromFiles(
+    userSetupAssistantJSON,
+    userSetupAssistantFunctions
+  );
+  const updatedManifest = {
+    ...manifest,
+    block_loading_for_setup: hasBlockingCondition
+  };
+  const resolvedSetupAssistant = manifest.setup_assistant ?? setupAssistantContent;
+  if (resolvedSetupAssistant !== void 0) {
+    updatedManifest.setup_assistant = resolvedSetupAssistant;
+  }
+  const resolvedUserSetupAssistant = manifest.user_setup_assistant ?? userSetupAssistantContent;
+  if (resolvedUserSetupAssistant !== void 0) {
+    updatedManifest.user_setup_assistant = resolvedUserSetupAssistant;
+  }
+  return {
+    [apiName]: {
+      manifest: updatedManifest,
+      thumbnail,
+      floatingFrames,
+      dataAdornments,
+      toolbarItems,
+      routablePages,
+      actions: jsActions,
+      routeScripts,
+      releaseNotes: releaseNotes?.content,
+      objectSettingsMenuItems: objectSettingsItems,
+      calendarSources,
+      automationSteps,
+      kznFile
+    }
+  };
+};
+var packagePlugin = (files, manifests) => {
+  const manifestArray = Array.isArray(manifests) ? manifests : [manifests];
+  return manifestArray.reduce((acc, manifest) => {
+    return { ...acc, ...processOnePluginFromManifest(manifest, files) };
+  }, {});
+};
+var parseManifestFromFiles = (files) => {
+  const manifestFile = files.find((f) => f.path === MANIFEST_FILE_NAME);
+  if (!manifestFile) {
+    throw new Error("Missing kizen.json at the root of the plugin directory.");
+  }
+  try {
+    return JSON.parse(manifestFile.content);
+  } catch {
+    throw new Error("kizen.json could not be parsed.");
+  }
+};
+
+// src/lib/transform.ts
+var formatBaseConfig = (packagedPlugin) => {
+  const assistantConfig = packagedPlugin.manifest.setup_assistant;
+  const actionsByApiName = Object.values(packagedPlugin.actions).reduce(
+    (acc, action) => {
+      acc[action.api_name] = action;
+      return acc;
+    },
+    {}
+  );
+  const userAssistantConfig = packagedPlugin.manifest.user_setup_assistant;
+  return {
+    ...packagedPlugin.manifest.base_config,
+    setup_assistant: assistantConfig ? {
+      ...assistantConfig,
+      actions: (assistantConfig.actions ?? []).map((apiName) => {
+        const action = actionsByApiName[apiName];
+        if (!action) {
+          throw new Error(
+            `Action with API name ${apiName} not found in packaged plugin for setup assistant. Allowed actions: ${Object.keys(actionsByApiName).join(", ")}`
+          );
+        }
+        return action;
+      })
+    } : void 0,
+    user_setup_assistant: userAssistantConfig,
+    block_loading_for_setup: packagedPlugin.manifest.block_loading_for_setup
+  };
+};
+var transformDeployablePlugin = (packagedPlugin) => {
+  const {
+    manifest,
+    floatingFrames,
+    dataAdornments,
+    routablePages,
+    toolbarItems,
+    actions,
+    routeScripts,
+    thumbnail,
+    releaseNotes,
+    objectSettingsMenuItems,
+    automationSteps,
+    calendarSources,
+    kznFile
+  } = packagedPlugin;
+  return {
+    ...manifest,
+    api_name: manifest.api_name,
+    artifacts: {
+      data_adornments: Object.values(dataAdornments),
+      floating_frames: Object.values(floatingFrames),
+      routable_pages: Object.values(routablePages),
+      toolbar_items: Object.values(toolbarItems),
+      js_action_templates: Object.values(actions),
+      route_scripts: Object.values(routeScripts),
+      object_settings_menu_items: Object.values(objectSettingsMenuItems),
+      automation_action_configs: Object.values(automationSteps),
+      calendar_sources: Object.values(calendarSources)
+    },
+    thumbnail,
+    kznFile,
+    releaseNotes,
+    base_config: formatBaseConfig(packagedPlugin),
+    setup_assistant: void 0,
+    services: manifest.services ?? []
+  };
+};
+export {
+  AUTOMATION_SCRIPT_FILE,
+  AUTOMATION_STEPS_DIRECTORY_NAME,
+  BROWSER_ROUTE_SCRIPTS_DIRECTORY_NAME,
+  CALENDAR_SOURCES_DIRECTORY_NAME,
+  CALLBACK_SCRIPT_FILE,
+  CONFIG_FILE_NAME,
+  DATA_ADORNMENTS_DIRECTORY_NAME,
+  EVENT_SCRIPTS_DIRECTORY_NAME,
+  FLOATING_FRAMES_DIRECTORY_NAME,
+  JS_ACTIONS_DIRECTORY_NAME,
+  KZN_FILE_NAME,
+  MAIN_SCRIPT_FILE,
+  MANIFEST_FILE_NAME,
+  MESSAGE_SCRIPT_FILE,
+  OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME,
+  RELEASE_NOTES_EXTENSION,
+  ROUTABLE_PAGES_DIRECTORY_NAME,
+  SCRIPT_EXTENSION,
+  SETUP_ASSISTANT_DIRECTORY_NAME,
+  STYLES_FILE_NAME,
+  THUMBNAIL_FILE_NAMES,
+  TOOLBAR_ITEMS_DIRECTORY_NAME,
+  USER_SETUP_ASSISTANT_DIRECTORY_NAME,
+  getAdornmentIcon,
+  getMinimizedConfig,
+  imagetoUint8Array,
+  maybeParseConfig,
+  minifyFiles,
+  packagePlugin,
+  parseManifestFromFiles,
+  sanitizeToAPIName,
+  scriptRuntimeToApiName,
+  thumbnailImageExtensions,
+  transformDeployablePlugin,
+  triggerImageExtensions,
+  zipToUint8Array
+};
+//# sourceMappingURL=index.js.map