next-workflow-builder 0.3.0

package/dist/chunk-Z3BJJYHM.js

@@ -0,0 +1,246 @@
+// src/plugins/index.ts
+var integrationRegistry = /* @__PURE__ */ new Map();
+var codegenTemplateRegistry = /* @__PURE__ */ new Map();
+var outputDisplayConfigRegistry = /* @__PURE__ */ new Map();
+function registerCodegenTemplates(templates) {
+  for (const [actionId, template] of Object.entries(templates)) {
+    codegenTemplateRegistry.set(actionId, template);
+  }
+}
+function getCodegenTemplate(actionId) {
+  return codegenTemplateRegistry.get(actionId);
+}
+function registerOutputDisplayConfigs(configs) {
+  for (const [actionId, config] of Object.entries(configs)) {
+    outputDisplayConfigRegistry.set(actionId, config);
+  }
+}
+function getOutputDisplayConfig(actionId) {
+  return outputDisplayConfigRegistry.get(actionId);
+}
+function computeActionId(integrationType, actionSlug) {
+  return `${integrationType}/${actionSlug}`;
+}
+function parseActionId(actionId) {
+  if (!actionId || typeof actionId !== "string") {
+    return null;
+  }
+  const parts = actionId.split("/");
+  if (parts.length !== 2) {
+    return null;
+  }
+  return { integration: parts[0], slug: parts[1] };
+}
+function registerIntegration(plugin) {
+  integrationRegistry.set(plugin.type, plugin);
+}
+function getIntegration(type) {
+  return integrationRegistry.get(type);
+}
+function getAllIntegrations() {
+  return Array.from(integrationRegistry.values());
+}
+function getIntegrationTypes() {
+  return Array.from(integrationRegistry.keys());
+}
+function getAllActions() {
+  const actions = [];
+  for (const plugin of integrationRegistry.values()) {
+    for (const action of plugin.actions) {
+      actions.push({
+        ...action,
+        id: computeActionId(plugin.type, action.slug),
+        integration: plugin.type
+      });
+    }
+  }
+  return actions;
+}
+function getActionsByCategory() {
+  const categories = {};
+  for (const plugin of integrationRegistry.values()) {
+    for (const action of plugin.actions) {
+      if (!categories[action.category]) {
+        categories[action.category] = [];
+      }
+      categories[action.category].push({
+        ...action,
+        id: computeActionId(plugin.type, action.slug),
+        integration: plugin.type
+      });
+    }
+  }
+  return categories;
+}
+function findActionById(actionId) {
+  if (!actionId) {
+    return void 0;
+  }
+  const parsed = parseActionId(actionId);
+  if (parsed) {
+    const plugin = integrationRegistry.get(parsed.integration);
+    if (plugin) {
+      const action = plugin.actions.find((a) => a.slug === parsed.slug);
+      if (action) {
+        return {
+          ...action,
+          id: actionId,
+          integration: plugin.type
+        };
+      }
+    }
+  }
+  for (const plugin of integrationRegistry.values()) {
+    const action = plugin.actions.find((a) => a.label === actionId);
+    if (action) {
+      return {
+        ...action,
+        id: computeActionId(plugin.type, action.slug),
+        integration: plugin.type
+      };
+    }
+  }
+  return void 0;
+}
+function getIntegrationLabels() {
+  const labels = {};
+  for (const plugin of integrationRegistry.values()) {
+    labels[plugin.type] = plugin.label;
+  }
+  return labels;
+}
+function getIntegrationDescriptions() {
+  const descriptions = {};
+  for (const plugin of integrationRegistry.values()) {
+    descriptions[plugin.type] = plugin.description;
+  }
+  return descriptions;
+}
+function getSortedIntegrationTypes() {
+  return Array.from(integrationRegistry.keys()).sort();
+}
+function getAllDependencies() {
+  const deps = {};
+  for (const plugin of integrationRegistry.values()) {
+    if (plugin.dependencies) {
+      Object.assign(deps, plugin.dependencies);
+    }
+  }
+  return deps;
+}
+function getDependenciesForActions(actionIds) {
+  const deps = {};
+  const integrations = /* @__PURE__ */ new Set();
+  for (const actionId of actionIds) {
+    const action = findActionById(actionId);
+    if (action) {
+      integrations.add(action.integration);
+    }
+  }
+  for (const integrationType of integrations) {
+    const plugin = integrationRegistry.get(integrationType);
+    if (plugin?.dependencies) {
+      Object.assign(deps, plugin.dependencies);
+    }
+  }
+  return deps;
+}
+function getPluginEnvVars(plugin) {
+  const envVars = [];
+  for (const field of plugin.formFields) {
+    if (field.envVar) {
+      envVars.push({
+        name: field.envVar,
+        description: field.helpText || field.label
+      });
+    }
+  }
+  return envVars;
+}
+function getAllEnvVars() {
+  const envVars = [];
+  for (const plugin of integrationRegistry.values()) {
+    envVars.push(...getPluginEnvVars(plugin));
+  }
+  return envVars;
+}
+function getCredentialMapping(plugin, config) {
+  const creds = {};
+  for (const field of plugin.formFields) {
+    if (field.envVar && config[field.configKey]) {
+      creds[field.envVar] = String(config[field.configKey]);
+    }
+  }
+  return creds;
+}
+function isFieldGroup(field) {
+  return field.type === "group";
+}
+function flattenConfigFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (isFieldGroup(field)) {
+      result.push(...field.fields);
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+function generateAIActionPrompts() {
+  const lines = [];
+  for (const plugin of integrationRegistry.values()) {
+    for (const action of plugin.actions) {
+      const fullId = computeActionId(plugin.type, action.slug);
+      const exampleConfig = {
+        actionType: fullId
+      };
+      const flatFields = flattenConfigFields(action.configFields);
+      for (const field of flatFields) {
+        if (field.showWhen) continue;
+        if (field.example !== void 0) {
+          exampleConfig[field.key] = field.example;
+        } else if (field.defaultValue !== void 0) {
+          exampleConfig[field.key] = field.defaultValue;
+        } else if (field.type === "number") {
+          exampleConfig[field.key] = 10;
+        } else if (field.type === "select" && field.options?.[0]) {
+          exampleConfig[field.key] = field.options[0].value;
+        } else {
+          exampleConfig[field.key] = `Your ${field.label.toLowerCase()}`;
+        }
+      }
+      lines.push(
+        `- ${action.label} (${fullId}): ${JSON.stringify(exampleConfig)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  registerCodegenTemplates,
+  getCodegenTemplate,
+  registerOutputDisplayConfigs,
+  getOutputDisplayConfig,
+  computeActionId,
+  parseActionId,
+  registerIntegration,
+  getIntegration,
+  getAllIntegrations,
+  getIntegrationTypes,
+  getAllActions,
+  getActionsByCategory,
+  findActionById,
+  getIntegrationLabels,
+  getIntegrationDescriptions,
+  getSortedIntegrationTypes,
+  getAllDependencies,
+  getDependenciesForActions,
+  getPluginEnvVars,
+  getAllEnvVars,
+  getCredentialMapping,
+  isFieldGroup,
+  flattenConfigFields,
+  generateAIActionPrompts
+};

package/dist/client/index.d.ts

@@ -0,0 +1,32 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { AuthUIProviderProps } from '@daveyplate/better-auth-ui';
+
+declare const WorkflowPage: () => react_jsx_runtime.JSX.Element | null;
+
+type Props = {
+    workflowId: string;
+};
+declare const WorkflowEditor: ({ workflowId }: Props) => react_jsx_runtime.JSX.Element;
+
+declare const Layout: (props: Omit<AuthUIProviderProps, "authClient">) => react_jsx_runtime.JSX.Element;
+
+/**
+ * AI Gateway Managed Keys Configuration
+ *
+ * This feature allows signed-in users to use their own Vercel AI Gateway
+ * API keys (and credits) instead of manually entering an API key.
+ *
+ * The AI Gateway itself is available to everyone via AI_GATEWAY_API_KEY.
+ * This feature flag only controls the ability to create API keys on behalf
+ * of users through OAuth - which is an internal Vercel feature.
+ *
+ * Set AI_GATEWAY_MANAGED_KEYS_ENABLED=true to enable.
+ */
+declare function isAiGatewayManagedKeysEnabled(): boolean;
+/**
+ * Check if managed keys feature is enabled on the client side
+ * Uses NEXT_PUBLIC_ prefix for client-side access
+ */
+declare function isAiGatewayManagedKeysEnabledClient(): boolean;
+
+export { Layout, WorkflowEditor, WorkflowPage, isAiGatewayManagedKeysEnabled, isAiGatewayManagedKeysEnabledClient };