vite-custom-functions-metadata/dist/index.js

Vite plugin for generating and injecting Custom Functions metadata

// src/index.ts
import { generateCustomFunctionsMetadata } from "custom-functions-metadata";
import path from "path";
import fs from "fs/promises";
var CustomFunctionsMetadataPlugin = class {
};
CustomFunctionsMetadataPlugin.generateResults = {};
function customFunctionsMetadataPlugin(options) {
  let config;
  let resolvedInputFiles = [];
  let generateResult;
  return {
    name: "vite:custom-functions-metadata",
    configResolved(resolvedConfig) {
      config = resolvedConfig;
      resolvedInputFiles = Array.isArray(options.input) ? options.input.map((file) => path.resolve(file)) : [path.resolve(options.input)];
    },
    async buildStart() {
      try {
        generateResult = await generateCustomFunctionsMetadata(resolvedInputFiles, true);
        if (generateResult.errors.length > 0) {
          generateResult.errors.forEach((err) => {
            this.error(new Error(`${options.input} ${err}`));
          });
        } else {
          CustomFunctionsMetadataPlugin.generateResults[Array.isArray(options.input) ? options.input[0] : options.input] = generateResult;
        }
      } catch (error) {
        this.error(new Error(`Failed to generate metadata: ${error.message}`));
      }
    },
    async transform(code, id) {
      const foundInputFile = resolvedInputFiles.find((file) => id.endsWith(file));
      if (!foundInputFile) {
        return null;
      }
      const inputKey = Array.isArray(options.input) ? options.input[0] : options.input;
      if (!CustomFunctionsMetadataPlugin.generateResults[inputKey]) {
        return code;
      }
      const associations = CustomFunctionsMetadataPlugin.generateResults[inputKey].associate.filter(
        (item) => item.sourceFileName === foundInputFile
      );
      let transformedCode = code;
      associations.forEach((item) => {
        transformedCode += `
CustomFunctions.associate("${item.id}", ${item.functionName});`;
      });
      return transformedCode;
    },
    async writeBundle() {
      if (generateResult && !generateResult.errors.length) {
        const outputPath = path.resolve(config.build.outDir, options.output);
        try {
          await fs.mkdir(path.dirname(outputPath), { recursive: true });
          await fs.writeFile(outputPath, generateResult.metadataJson);
        } catch (error) {
          this.error(`Failed to write metadata file: ${error.message}`);
        }
      }
    },
    configureServer(server) {
      return () => {
        server.middlewares.use(async (req, res, next) => {
          if (generateResult && !generateResult.errors.length && req.url?.endsWith(options.output)) {
            const outputPath = path.resolve(server.config.root, options.output);
            try {
              await fs.mkdir(path.dirname(outputPath), { recursive: true });
              await fs.writeFile(outputPath, generateResult.metadataJson);
              res.setHeader("Content-Type", "application/json");
              res.end(generateResult.metadataJson);
              return;
            } catch (error) {
              console.error(`Failed to write metadata file: ${error.message}`);
            }
          }
          next();
        });
      };
    }
  };
}
var index_default = customFunctionsMetadataPlugin;
export {
  customFunctionsMetadataPlugin,
  index_default as default
};
//# sourceMappingURL=index.js.map