next-workflow-builder 0.3.0

package/dist/chunk-D44JFQYX.js

@@ -0,0 +1,546 @@
+import {
+  CODEGEN_REGISTRY_FILE,
+  GITIGNORE_FILE,
+  LEADING_WHITESPACE_PATTERN,
+  OUTPUT_CONFIGS_FILE,
+  OUTPUT_FILE,
+  PLUGINS_DIR,
+  STEP_REGISTRY_FILE,
+  SYSTEM_INTEGRATION_TYPES,
+  TYPES_FILE
+} from "./chunk-OQHML4II.js";
+import {
+  computeActionId,
+  getAllIntegrations,
+  getIntegrationTypes
+} from "./chunk-Z3BJJYHM.js";
+
+// src/plugins/discover.ts
+import { createJiti } from "jiti";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, join, relative } from "path";
+import ts from "typescript";
+async function formatCode(code) {
+  try {
+    const prettier = await import("prettier");
+    return await prettier.format(code, { parser: "typescript" });
+  } catch (error) {
+    console.warn("   Warning: Failed to format generated code:", error);
+    return code;
+  }
+}
+var generatedCodegenTemplates = /* @__PURE__ */ new Map();
+function generateIndexFile(plugins) {
+  const imports = plugins.map((plugin) => `import "./${plugin}";`).join("\n");
+  const content = `/**
+ * Plugins Index (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * To add a new integration:
+ * 1. Create a new directory in plugins/ (e.g., plugins/my-integration/)
+ * 2. Add your plugin files (index.tsx, steps/, codegen/, etc.)
+ * 3. Run: pnpm discover-plugins (or it runs automatically on build)
+ *
+ * To remove an integration:
+ * 1. Delete the plugin directory
+ * 2. Run: pnpm discover-plugins (or it runs automatically on build)
+ */
+
+// Side-effect imports: each plugin calls registerIntegration() on import
+${imports || "// No plugins discovered"}
+
+// Re-export registry utilities so consuming apps can import from "@/plugins"
+export {
+  computeActionId,
+  findActionById,
+  flattenConfigFields,
+  generateAIActionPrompts,
+  getActionsByCategory,
+  getAllActions,
+  getAllDependencies,
+  getAllEnvVars,
+  getAllIntegrations,
+  getCredentialMapping,
+  getDependenciesForActions,
+  getIntegration,
+  getIntegrationLabels,
+  getIntegrationTypes,
+  getPluginEnvVars,
+  getSortedIntegrationTypes,
+  isFieldGroup,
+  parseActionId,
+  registerIntegration,
+} from "next-workflow-builder/plugins";
+
+export type {
+  ActionConfigField,
+  ActionConfigFieldBase,
+  ActionConfigFieldGroup,
+  ActionWithFullId,
+  IntegrationPlugin,
+  PluginAction,
+} from "next-workflow-builder/plugins";
+`;
+  writeFileSync(OUTPUT_FILE, content, "utf-8");
+}
+async function generateTypesFile() {
+  const typesDir = dirname(TYPES_FILE);
+  if (!existsSync(typesDir)) {
+    mkdirSync(typesDir, { recursive: true });
+  }
+  const pluginTypes = getIntegrationTypes();
+  const allTypes = [...pluginTypes, ...SYSTEM_INTEGRATION_TYPES].sort();
+  const unionType = allTypes.map((t) => `  | "${t}"`).join("\n");
+  const content = `/**
+ * Integration Types (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * To add a new integration type:
+ * 1. Create a plugin in plugins/ directory, OR
+ * 2. Add a system integration to SYSTEM_INTEGRATION_TYPES in discover-plugins.ts
+ * 3. Run: pnpm discover-plugins
+ *
+ * Generated types: ${allTypes.join(", ")}
+ */
+
+// Integration type union - plugins + system integrations
+export type IntegrationType =
+${unionType};
+
+// Generic config type - plugins define their own keys via formFields[].configKey
+export type IntegrationConfig = Record<string, string | undefined>;
+`;
+  writeFileSync(TYPES_FILE, content, "utf-8");
+  console.log(
+    `Generated lib/types/integration.ts with ${allTypes.length} type(s)`
+  );
+}
+function generateCodegenRegistry() {
+  const entries = Array.from(generatedCodegenTemplates.entries());
+  if (entries.length === 0) {
+    console.log("No codegen templates generated");
+    return;
+  }
+  const templateEntries = entries.map(([actionId, { template }]) => {
+    const escapedTemplate = template.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+    return `  "${actionId}": \`${escapedTemplate}\`,`;
+  }).join("\n\n");
+  const content = `/**
+ * Codegen Registry (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * Contains auto-generated codegen templates for steps with stepHandler.
+ * These templates are used when exporting workflows to standalone projects.
+ *
+ * Generated templates: ${entries.length}
+ */
+
+/**
+ * Auto-generated codegen templates
+ * Maps action IDs to their generated export code templates
+ */
+export const AUTO_GENERATED_TEMPLATES: Record<string, string> = {
+${templateEntries}
+};
+
+/**
+ * Get the auto-generated codegen template for an action
+ */
+export function getAutoGeneratedTemplate(actionId: string): string | undefined {
+  return AUTO_GENERATED_TEMPLATES[actionId];
+}
+`;
+  writeFileSync(CODEGEN_REGISTRY_FILE, content, "utf-8");
+  console.log(
+    `Generated lib/codegen-registry.ts with ${entries.length} template(s)`
+  );
+}
+async function generateStepRegistry() {
+  const integrations = getAllIntegrations();
+  const stepEntries = [];
+  for (const integration of integrations) {
+    for (const action of integration.actions) {
+      const fullActionId = computeActionId(integration.type, action.slug);
+      stepEntries.push({
+        actionId: fullActionId,
+        label: action.label,
+        integration: integration.type,
+        stepImportPath: action.stepImportPath,
+        stepFunction: action.stepFunction
+      });
+    }
+  }
+  const importerEntries = stepEntries.flatMap(({ actionId, integration, stepImportPath, stepFunction }) => {
+    return [
+      `  "${actionId}": {
+    importer: () => import("@/plugins/${integration}/steps/${stepImportPath}"),
+    stepFunction: "${stepFunction}",
+  },`
+    ];
+  }).join("\n");
+  const labelEntries = stepEntries.map(({ actionId, label }) => `  "${actionId}": "${label}",`).join("\n");
+  const content = `/**
+ * Step Registry (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * This registry enables dynamic step imports that are statically analyzable
+ * by the bundler. Each action type maps to its step importer function.
+ *
+ * Generated entries: ${stepEntries.length}
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic step module types - step functions take any input
+export type StepFunction = (input: any) => Promise<any>;
+
+// Step modules may contain the step function plus other exports (types, constants, etc.)
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic module with mixed exports
+export type StepModule = Record<string, any>;
+
+export type StepImporter = {
+  importer: () => Promise<StepModule>;
+  stepFunction: string;
+};
+
+/**
+ * Plugin step importers - maps action types to their step import functions
+ * These imports are statically analyzable by the bundler
+ */
+export const PLUGIN_STEP_IMPORTERS: Record<string, StepImporter> = {
+${importerEntries}
+};
+
+/**
+ * Action labels - maps action IDs to human-readable labels
+ * Used for displaying friendly names in the UI (e.g., Runs tab)
+ */
+export const ACTION_LABELS: Record<string, string> = {
+${labelEntries}
+};
+
+/**
+ * Get a step importer for an action type
+ */
+export function getStepImporter(actionType: string): StepImporter | undefined {
+  return PLUGIN_STEP_IMPORTERS[actionType];
+}
+
+/**
+ * Get the human-readable label for an action type
+ */
+export function getActionLabel(actionType: string): string | undefined {
+  return ACTION_LABELS[actionType];
+}
+`;
+  writeFileSync(STEP_REGISTRY_FILE, content, "utf-8");
+  console.log(
+    `Generated lib/step-registry.ts with ${stepEntries.length} step(s)`
+  );
+}
+async function generateOutputDisplayConfigs() {
+  const integrations = getAllIntegrations();
+  const outputConfigs = [];
+  for (const integration of integrations) {
+    for (const action of integration.actions) {
+      if (action.outputConfig && action.outputConfig.type !== "component") {
+        outputConfigs.push({
+          actionId: computeActionId(integration.type, action.slug),
+          type: action.outputConfig.type,
+          field: action.outputConfig.field
+        });
+      }
+    }
+  }
+  const outputConfigEntries = outputConfigs.map(
+    ({ actionId, type, field }) => `  "${actionId}": { type: "${type}", field: "${field}" },`
+  ).join("\n");
+  const content = `/**
+ * Output Display Configs (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * This file is CLIENT-SAFE and can be imported in client components.
+ * It maps action IDs to their output display configuration.
+ *
+ * Generated configs: ${outputConfigs.length}
+ */
+
+export type OutputDisplayConfig = {
+  type: "image" | "video" | "url";
+  field: string;
+};
+
+/**
+ * Output display configs - maps action IDs to their display configuration
+ * Used for rendering outputs in the workflow runs panel
+ */
+export const OUTPUT_DISPLAY_CONFIGS: Record<string, OutputDisplayConfig> = {
+${outputConfigEntries}
+};
+
+/**
+ * Get the output display config for an action type
+ */
+export function getOutputDisplayConfig(actionType: string): OutputDisplayConfig | undefined {
+  return OUTPUT_DISPLAY_CONFIGS[actionType];
+}
+`;
+  writeFileSync(OUTPUT_CONFIGS_FILE, content, "utf-8");
+  console.log(
+    `Generated lib/output-display-configs.ts with ${outputConfigs.length} config(s)`
+  );
+}
+function shouldIncludeImport(moduleSpec, importText) {
+  if (moduleSpec.startsWith("@/") || moduleSpec.startsWith(".")) {
+    return false;
+  }
+  if (importText.includes("server-only")) {
+    return false;
+  }
+  return true;
+}
+function extractFunctionInfo(node, sourceCode) {
+  if (!(node.name && node.body)) {
+    return null;
+  }
+  const params = node.parameters.map((p) => sourceCode.slice(p.pos, p.end).trim()).join(", ");
+  const returnType = node.type ? sourceCode.slice(node.type.pos, node.type.end).trim() : "Promise<unknown>";
+  const body = sourceCode.slice(node.body.pos, node.body.end).trim();
+  return {
+    name: node.name.text,
+    params,
+    returnType,
+    body
+  };
+}
+function createEmptyAnalysis() {
+  return {
+    hasExportCore: false,
+    integrationType: null,
+    coreFunction: null,
+    inputTypes: [],
+    imports: []
+  };
+}
+function processExportedVariable(decl, result) {
+  if (!ts.isIdentifier(decl.name)) {
+    return;
+  }
+  const name = decl.name.text;
+  const init = decl.initializer;
+  if (name === "_integrationType" && init && ts.isStringLiteral(init)) {
+    result.integrationType = init.text;
+  }
+}
+function processVariableStatement(node, result) {
+  const isExported = node.modifiers?.some(
+    (m) => m.kind === ts.SyntaxKind.ExportKeyword
+  );
+  if (!isExported) {
+    return;
+  }
+  for (const decl of node.declarationList.declarations) {
+    processExportedVariable(decl, result);
+  }
+}
+function shouldIncludeType(typeName) {
+  return typeName.endsWith("Result") || typeName.endsWith("Credentials") || typeName.endsWith("CoreInput");
+}
+function processTypeAlias(node, sourceCode, result) {
+  if (shouldIncludeType(node.name.text)) {
+    result.inputTypes.push(sourceCode.slice(node.pos, node.end).trim());
+  }
+}
+function processImportDeclaration(node, sourceCode, result) {
+  const spec = node.moduleSpecifier;
+  if (!ts.isStringLiteral(spec)) {
+    return;
+  }
+  const importText = sourceCode.slice(node.pos, node.end).trim();
+  if (shouldIncludeImport(spec.text, importText)) {
+    result.imports.push(importText);
+  }
+}
+function processNode(node, sourceCode, result) {
+  if (ts.isVariableStatement(node)) {
+    processVariableStatement(node, result);
+    return;
+  }
+  if (ts.isTypeAliasDeclaration(node)) {
+    processTypeAlias(node, sourceCode, result);
+    return;
+  }
+  if (ts.isImportDeclaration(node)) {
+    processImportDeclaration(node, sourceCode, result);
+    return;
+  }
+  if (ts.isFunctionDeclaration(node) && node.name?.text === "stepHandler") {
+    result.hasExportCore = true;
+    result.coreFunction = extractFunctionInfo(node, sourceCode);
+  }
+}
+function analyzeStepFile(filePath) {
+  const result = createEmptyAnalysis();
+  if (!existsSync(filePath)) {
+    return result;
+  }
+  const sourceCode = readFileSync(filePath, "utf-8");
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  ts.forEachChild(sourceFile, (node) => {
+    processNode(node, sourceCode, result);
+  });
+  return result;
+}
+async function generateCodegenTemplate(stepFilePath, stepFunctionName) {
+  const analysis = analyzeStepFile(stepFilePath);
+  if (!(analysis.hasExportCore && analysis.coreFunction)) {
+    return null;
+  }
+  const { coreFunction, integrationType, inputTypes, imports } = analysis;
+  let innerBody = coreFunction.body.trim();
+  if (innerBody.startsWith("{")) {
+    innerBody = innerBody.slice(1);
+  }
+  if (innerBody.endsWith("}")) {
+    innerBody = innerBody.slice(0, -1);
+  }
+  innerBody = innerBody.trim();
+  const inputType = coreFunction.params.split(",")[0].replace(LEADING_WHITESPACE_PATTERN, "").split(":")[1]?.trim() || "unknown";
+  const rawTemplate = `${imports.join("\n")}
+import { fetchCredentials } from './lib/credential-helper';
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+${inputTypes.join("\n\n")}
+
+export async function ${stepFunctionName}(input: ${inputType}): ${coreFunction.returnType} {
+  "use step";
+  const credentials = await fetchCredentials("${integrationType || "unknown"}");
+${innerBody}
+}`;
+  return await formatCode(rawTemplate);
+}
+async function processStepFilesForCodegen() {
+  const integrations = getAllIntegrations();
+  for (const integration of integrations) {
+    for (const action of integration.actions) {
+      const stepFilePath = join(
+        PLUGINS_DIR,
+        integration.type,
+        "steps",
+        `${action.stepImportPath}.ts`
+      );
+      const template = await generateCodegenTemplate(
+        stepFilePath,
+        action.stepFunction
+      );
+      if (template) {
+        const actionId = computeActionId(integration.type, action.slug);
+        generatedCodegenTemplates.set(actionId, {
+          template,
+          integrationType: integration.type
+        });
+        console.log(`   Generated codegen template for ${actionId}`);
+      }
+    }
+  }
+}
+function ensureGitignore() {
+  const SECTION_HEADER = "\n# Auto-generated by discover-plugins";
+  const filesToIgnore = [
+    TYPES_FILE,
+    CODEGEN_REGISTRY_FILE,
+    STEP_REGISTRY_FILE,
+    OUTPUT_CONFIGS_FILE,
+    OUTPUT_FILE
+  ];
+  const relativePaths = filesToIgnore.map((file) => relative(process.cwd(), file));
+  let content = "";
+  if (existsSync(GITIGNORE_FILE)) {
+    content = readFileSync(GITIGNORE_FILE, "utf-8");
+  }
+  const existingLines = new Set(content.split("\n").map((line) => line.trim()));
+  const newEntries = relativePaths.filter((entry) => !existingLines.has(entry));
+  if (newEntries.length > 0) {
+    let textToAppend = "";
+    if (content.length > 0 && !content.endsWith("\n")) {
+      textToAppend += "\n";
+    }
+    if (!content.includes(SECTION_HEADER)) {
+      textToAppend += `${SECTION_HEADER}
+`;
+    }
+    textToAppend += newEntries.join("\n") + "\n";
+    writeFileSync(GITIGNORE_FILE, content + textToAppend, "utf-8");
+    console.log(`Updated .gitignore with ${newEntries.length} new file(s).`);
+  }
+}
+async function discoverPlugins() {
+  console.log("Discovering plugins...");
+  const entries = readdirSync(PLUGINS_DIR);
+  const plugins = entries.filter((entry) => {
+    if (entry.startsWith("_") || entry.startsWith(".") || entry === "index.ts" || entry === "registry.ts") {
+      return false;
+    }
+    const fullPath = join(PLUGINS_DIR, entry);
+    try {
+      return statSync(fullPath).isDirectory();
+    } catch {
+      return false;
+    }
+  }).sort();
+  if (plugins.length === 0) {
+    console.log("No plugins found in plugins/ directory");
+  } else {
+    console.log(`Found ${plugins.length} plugin(s):`);
+    for (const plugin of plugins) {
+      console.log(`   - ${plugin}`);
+    }
+  }
+  ensureGitignore();
+  console.log("Generating plugins/index.ts...");
+  generateIndexFile(plugins);
+  if (plugins.length > 0) {
+    console.log("Registering plugins...\n");
+    const jiti = createJiti(import.meta.url, { jsx: true });
+    for (const plugin of plugins) {
+      try {
+        await jiti.import(join(PLUGINS_DIR, plugin));
+        console.log(`   Registered: ${plugin}`);
+      } catch (error) {
+        console.warn(`   Warning: Failed to import plugin ${plugin}:`, error);
+      }
+    }
+  }
+  console.log("Generating lib/types/integration.ts...");
+  await generateTypesFile();
+  console.log("Generating lib/step-registry.ts...");
+  await generateStepRegistry();
+  console.log("Generating lib/output-display-configs.ts...");
+  await generateOutputDisplayConfigs();
+  console.log("\nProcessing step files for codegen templates...");
+  await processStepFilesForCodegen();
+  console.log("Generating lib/codegen-registry.ts...");
+  generateCodegenRegistry();
+  console.log("Done! Plugin registry updated.\n");
+}
+
+export {
+  discoverPlugins
+};

package/dist/chunk-DJ7ANVJ3.js

@@ -0,0 +1,51 @@
+import {
+  getIntegrationById
+} from "./chunk-BNYDOC3I.js";
+import {
+  getCredentialMapping,
+  getIntegration
+} from "./chunk-Z3BJJYHM.js";
+
+// src/server/lib/credential-fetcher.ts
+var SYSTEM_CREDENTIAL_MAPPERS = {
+  database: (config) => {
+    const creds = {};
+    if (config.url) {
+      creds.DATABASE_URL = config.url;
+    }
+    return creds;
+  }
+};
+function mapIntegrationConfig(integrationType, config) {
+  const systemMapper = SYSTEM_CREDENTIAL_MAPPERS[integrationType];
+  if (systemMapper) {
+    return systemMapper(config);
+  }
+  const plugin = getIntegration(integrationType);
+  if (plugin) {
+    return getCredentialMapping(plugin, config);
+  }
+  return {};
+}
+async function fetchCredentials(integrationId) {
+  console.log("[Credential Fetcher] Fetching integration:", integrationId);
+  const integration = await getIntegrationById(integrationId);
+  if (!integration) {
+    console.log("[Credential Fetcher] Integration not found");
+    return {};
+  }
+  console.log("[Credential Fetcher] Found integration:", integration.type);
+  const credentials = mapIntegrationConfig(
+    integration.type,
+    integration.config
+  );
+  console.log(
+    "[Credential Fetcher] Returning credentials for type:",
+    integration.type
+  );
+  return credentials;
+}
+
+export {
+  fetchCredentials
+};

package/dist/chunk-O3I2INCD.js

@@ -0,0 +1,71 @@
+// src/server/lib/utils.ts
+function getErrorMessage(error) {
+  if (error === null || error === void 0) {
+    return "Unknown error";
+  }
+  if (error instanceof Error) {
+    if (error.cause && error.cause instanceof Error) {
+      return `${error.message}: ${error.cause.message}`;
+    }
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object") {
+    const obj = error;
+    if (typeof obj.message === "string" && obj.message) {
+      return obj.message;
+    }
+    if (obj.responseBody && typeof obj.responseBody === "object") {
+      const body = obj.responseBody;
+      if (typeof body.error === "string") {
+        return body.error;
+      }
+      if (body.error && typeof body.error === "object" && typeof body.error.message === "string") {
+        return body.error.message;
+      }
+    }
+    if (typeof obj.error === "string" && obj.error) {
+      return obj.error;
+    }
+    if (obj.error && typeof obj.error === "object") {
+      const nestedError = obj.error;
+      if (typeof nestedError.message === "string") {
+        return nestedError.message;
+      }
+    }
+    if (obj.data && typeof obj.data === "object") {
+      const data = obj.data;
+      if (typeof data.error === "string") {
+        return data.error;
+      }
+      if (typeof data.message === "string") {
+        return data.message;
+      }
+    }
+    if (typeof obj.reason === "string" && obj.reason) {
+      return obj.reason;
+    }
+    if (typeof obj.statusText === "string" && obj.statusText) {
+      const status = typeof obj.status === "number" ? ` (${obj.status})` : "";
+      return `${obj.statusText}${status}`;
+    }
+    try {
+      const stringified = JSON.stringify(error, null, 0);
+      if (stringified && stringified !== "{}" && stringified.length < 500) {
+        return stringified;
+      }
+    } catch {
+    }
+    const toString = Object.prototype.toString.call(error);
+    if (toString !== "[object Object]") {
+      return toString;
+    }
+  }
+  return "Unknown error";
+}
+
+export {
+  getErrorMessage
+};

package/dist/chunk-OQHML4II.js

@@ -0,0 +1,36 @@
+// src/server/constants.ts
+import { join } from "path";
+var CWD = process.cwd();
+var PLUGINS_DIR = join(CWD, "plugins");
+var LIB_DIR = join(CWD, "lib");
+var OUTPUT_FILE = join(PLUGINS_DIR, "index.ts");
+var TYPES_FILE = join(LIB_DIR, "types", "integration.ts");
+var GITIGNORE_FILE = join(CWD, ".gitignore");
+var STEP_REGISTRY_FILE = join(LIB_DIR, "step-registry.ts");
+var OUTPUT_CONFIGS_FILE = join(LIB_DIR, "output-display-configs.ts");
+var CODEGEN_REGISTRY_FILE = join(LIB_DIR, "codegen-registry.ts");
+var SYSTEM_INTEGRATION_TYPES = ["database"];
+var LEADING_WHITESPACE_PATTERN = /^\s*/;
+var BOILERPLATE_PATH = join(".", "lib", "next-boilerplate");
+var CODEGEN_TEMPLATES_PATH = join(process.cwd(), "lib", "codegen-templates");
+var NON_ALPHANUMERIC_REGEX = /[^a-zA-Z0-9\s]/g;
+var WHITESPACE_SPLIT_REGEX = /\s+/;
+var TEMPLATE_EXPORT_REGEX = /export default `([\s\S]*)`/;
+var IS_PRODUCTION = process.env.NODE_ENV === "production";
+
+export {
+  PLUGINS_DIR,
+  OUTPUT_FILE,
+  TYPES_FILE,
+  GITIGNORE_FILE,
+  STEP_REGISTRY_FILE,
+  OUTPUT_CONFIGS_FILE,
+  CODEGEN_REGISTRY_FILE,
+  SYSTEM_INTEGRATION_TYPES,
+  LEADING_WHITESPACE_PATTERN,
+  BOILERPLATE_PATH,
+  CODEGEN_TEMPLATES_PATH,
+  NON_ALPHANUMERIC_REGEX,
+  WHITESPACE_SPLIT_REGEX,
+  TEMPLATE_EXPORT_REGEX
+};