@sdeverywhere/build 0.3.3 → 0.3.5

package/dist/index.js

@@ -4,7 +4,7 @@ import { err as err3, ok as ok3 } from "neverthrow";
 
 // src/config/config-loader.ts
 import { existsSync, lstatSync, mkdirSync } from "fs";
-import { dirname, join as joinPath, relative, resolve as resolvePath } from "path";
+import { dirname, isAbsolute, join as joinPath, relative, resolve as resolvePath } from "path";
 import { fileURLToPath } from "url";
 import { err, ok } from "neverthrow";
 async function loadConfig(mode, config, sdeDir, sdeCmdPath) {
@@ -82,6 +82,26 @@ function resolveUserConfig(userConfig, mode, sdeDir, sdeCmdPath) {
   } else {
     watchPaths = modelFiles;
   }
+  const rawGenFormat = userConfig.genFormat || "js";
+  let genFormat;
+  switch (rawGenFormat) {
+    case "js":
+      genFormat = "js";
+      break;
+    case "c":
+      genFormat = "c";
+      break;
+    default:
+      throw new Error(`The configured genFormat value is invalid; must be either 'js' or 'c'`);
+  }
+  let outListingFile;
+  if (userConfig.outListingFile) {
+    if (isAbsolute(userConfig.outListingFile)) {
+      outListingFile = userConfig.outListingFile;
+    } else {
+      outListingFile = resolvePath(rootDir, userConfig.outListingFile);
+    }
+  }
   return {
     mode,
     rootDir,
@@ -89,6 +109,8 @@ function resolveUserConfig(userConfig, mode, sdeDir, sdeCmdPath) {
     modelFiles,
     modelInputPaths,
     watchPaths,
+    genFormat,
+    outListingFile,
     sdeDir,
     sdeCmdPath
   };
@@ -476,7 +498,7 @@ function filesDiffer(aPath, bPath) {
 
 // src/build/impl/gen-model.ts
 import { copyFile, readdir, readFile, writeFile } from "fs/promises";
-import { join as joinPath3 } from "path";
+import { basename, dirname as dirname2, join as joinPath3 } from "path";
 async function generateModel(context, plugins) {
   const config = context.config;
   if (config.modelFiles.length === 0) {
@@ -506,18 +528,33 @@ async function generateModel(context, plugins) {
     }
   }
   for (const plugin of plugins) {
-    if (plugin.preGenerateC) {
-      await plugin.preGenerateC(context);
+    if (plugin.preGenerateCode) {
+      await plugin.preGenerateCode(context, config.genFormat);
     }
   }
-  await generateC(context, config.sdeDir, sdeCmdPath, prepDir);
+  await generateCode(context, config.sdeDir, sdeCmdPath, prepDir);
+  const generatedCodeFile = `processed.${config.genFormat}`;
+  const generatedCodePath = joinPath3(prepDir, "build", generatedCodeFile);
   for (const plugin of plugins) {
-    if (plugin.postGenerateC) {
-      const cPath = joinPath3(prepDir, "build", "processed.c");
-      let cContent = await readFile(cPath, "utf8");
-      cContent = await plugin.postGenerateC(context, cContent);
-      await writeFile(cPath, cContent);
-    }
+    if (plugin.postGenerateCode) {
+      let generatedCodeContent = await readFile(generatedCodePath, "utf8");
+      generatedCodeContent = await plugin.postGenerateCode(context, config.genFormat, generatedCodeContent);
+      await writeFile(generatedCodePath, generatedCodeContent);
+    }
+  }
+  if (config.genFormat === "js") {
+    const outputJsFile = "generated-model.js";
+    const stagedOutputJsPath = context.prepareStagedFile("model", outputJsFile, prepDir, outputJsFile);
+    await copyFile(generatedCodePath, stagedOutputJsPath);
+  }
+  if (config.outListingFile) {
+    const srcListingJsonPath = joinPath3(prepDir, "build", "processed.json");
+    const stagedDir = "model";
+    const stagedFile = "listing.json";
+    const dstDir = dirname2(config.outListingFile);
+    const dstFile = basename(config.outListingFile);
+    const stagedListingJsonPath = context.prepareStagedFile(stagedDir, stagedFile, dstDir, dstFile);
+    await copyFile(srcListingJsonPath, stagedListingJsonPath);
   }
   const t1 = performance.now();
   const elapsed = ((t1 - t0) / 1e3).toFixed(1);
@@ -528,7 +565,14 @@ async function preprocessMdl(context, sdeCmdPath, prepDir, modelFile) {
   await copyFile(modelFile, joinPath3(prepDir, "processed.mdl"));
   const command = sdeCmdPath;
   const args = ["generate", "--preprocess", "processed.mdl"];
-  await context.spawnChild(prepDir, command, args);
+  const ppOutput = await context.spawnChild(prepDir, command, args, {
+    // The default error message from `spawnChild` is not very informative, so the
+    // following allows us to throw our own error
+    ignoreError: true
+  });
+  if (ppOutput.exitCode !== 0) {
+    throw new Error(`Failed to preprocess mdl file: 'sde generate' command failed (code=${ppOutput.exitCode})`);
+  }
   await copyFile(joinPath3(prepDir, "build", "processed.mdl"), joinPath3(prepDir, "processed.mdl"));
 }
 async function flattenMdls(context, sdeCmdPath, prepDir, modelFiles) {
@@ -561,31 +605,44 @@ async function flattenMdls(context, sdeCmdPath, prepDir, modelFiles) {
         log("error", `  ${line}`);
       }
     }
-    throw new Error(`Flatten command failed (code=${output.exitCode})`);
+    throw new Error(`Failed to flatten mdl files: 'sde flatten' command failed (code=${output.exitCode})`);
   } else if (output.exitCode !== 0) {
-    throw new Error(`Flatten command failed (code=${output.exitCode})`);
+    throw new Error(`Failed to flatten mdl files: 'sde flatten' command failed (code=${output.exitCode})`);
   }
   await copyFile(joinPath3(prepDir, "build", "processed.mdl"), joinPath3(prepDir, "processed.mdl"));
 }
-async function generateC(context, sdeDir, sdeCmdPath, prepDir) {
-  log("verbose", "  Generating C code");
+async function generateCode(context, sdeDir, sdeCmdPath, prepDir) {
+  const genFormat = context.config.genFormat;
+  const genFormatName = genFormat.toUpperCase();
+  log("verbose", `  Generating ${genFormatName} code`);
   const command = sdeCmdPath;
-  const gencArgs = ["generate", "--genc", "--list", "--spec", "spec.json", "processed"];
-  await context.spawnChild(prepDir, command, gencArgs, {
+  const outFormat = `--outformat=${genFormat}`;
+  const genCmdArgs = ["generate", outFormat, "--list", "--spec", "spec.json", "processed"];
+  const genCmdOutput = await context.spawnChild(prepDir, command, genCmdArgs, {
     // By default, ignore lines that start with "WARNING: Data for" since these are often harmless
     // TODO: Don't filter by default, but make it configurable
     // ignoredMessageFilter: 'WARNING: Data for'
+    // The default error message from `spawnChild` is not very informative, so the
+    // following allows us to throw our own error
+    ignoreError: true
   });
-  const buildDir = joinPath3(prepDir, "build");
-  const sdeCDir = joinPath3(sdeDir, "src", "c");
-  const files = await readdir(sdeCDir);
-  const copyOps = [];
-  for (const file of files) {
-    if (file.endsWith(".c") || file.endsWith(".h")) {
-      copyOps.push(copyFile(joinPath3(sdeCDir, file), joinPath3(buildDir, file)));
+  if (genCmdOutput.exitCode !== 0) {
+    throw new Error(
+      `Failed to generate ${genFormatName} code: 'sde generate' command failed (code=${genCmdOutput.exitCode})`
+    );
+  }
+  if (genFormat === "c") {
+    const buildDir = joinPath3(prepDir, "build");
+    const sdeCDir = joinPath3(sdeDir, "src", "c");
+    const files = await readdir(sdeCDir);
+    const copyOps = [];
+    for (const file of files) {
+      if (file.endsWith(".c") || file.endsWith(".h")) {
+        copyOps.push(copyFile(joinPath3(sdeCDir, file), joinPath3(buildDir, file)));
+      }
     }
+    await Promise.all(copyOps);
   }
-  await Promise.all(copyOps);
 }
 
 // src/build/impl/hash-files.ts
@@ -620,45 +677,44 @@ async function computeInputFilesHash(config) {
 async function buildOnce(config, userConfig, plugins, options) {
   const stagedFiles = new StagedFiles(config.prepDir);
   const context = new BuildContext(config, stagedFiles, options.abortSignal);
-  let modelSpec;
+  const modelHashPath = joinPath5(config.prepDir, "model-hash.txt");
+  let succeeded = true;
   try {
-    modelSpec = await userConfig.modelSpec(context);
-    if (modelSpec === void 0) {
+    const userModelSpec = await userConfig.modelSpec(context);
+    if (userModelSpec === void 0) {
       return err2(new Error("The model spec must be defined"));
     }
-  } catch (e) {
-    return err2(e);
-  }
-  for (const plugin of plugins) {
-    if (plugin.preGenerate) {
-      plugin.preGenerate(context, modelSpec);
+    const modelSpec = resolveModelSpec(userModelSpec);
+    for (const plugin of plugins) {
+      if (plugin.preGenerate) {
+        await plugin.preGenerate(context, modelSpec);
+      }
+    }
+    const specJson = {
+      inputVarNames: modelSpec.inputVarNames,
+      outputVarNames: modelSpec.outputVarNames,
+      externalDatfiles: modelSpec.datFiles,
+      bundleListing: modelSpec.bundleListing,
+      customLookups: modelSpec.customLookups,
+      customOutputs: modelSpec.customOutputs,
+      ...modelSpec.options
+    };
+    const specPath = joinPath5(config.prepDir, "spec.json");
+    await writeFile2(specPath, JSON.stringify(specJson, null, 2));
+    let previousModelHash;
+    if (existsSync3(modelHashPath)) {
+      previousModelHash = readFileSync2(modelHashPath, "utf8");
+    } else {
+      previousModelHash = "NONE";
+    }
+    const inputFilesHash = await computeInputFilesHash(config);
+    let needModelGen;
+    if (options.forceModelGen === true) {
+      needModelGen = true;
+    } else {
+      const hashMismatch = inputFilesHash !== previousModelHash;
+      needModelGen = hashMismatch;
     }
-  }
-  const specJson = {
-    inputVarNames: modelSpec.inputs.map((input) => input.varName),
-    outputVarNames: modelSpec.outputs.map((output) => output.varName),
-    externalDatfiles: modelSpec.datFiles,
-    ...modelSpec.options
-  };
-  const specPath = joinPath5(config.prepDir, "spec.json");
-  await writeFile2(specPath, JSON.stringify(specJson, null, 2));
-  const modelHashPath = joinPath5(config.prepDir, "model-hash.txt");
-  let previousModelHash;
-  if (existsSync3(modelHashPath)) {
-    previousModelHash = readFileSync2(modelHashPath, "utf8");
-  } else {
-    previousModelHash = "NONE";
-  }
-  const inputFilesHash = await computeInputFilesHash(config);
-  let needModelGen;
-  if (options.forceModelGen === true) {
-    needModelGen = true;
-  } else {
-    const hashMismatch = inputFilesHash !== previousModelHash;
-    needModelGen = hashMismatch;
-  }
-  let succeeded = true;
-  try {
     if (needModelGen) {
       await generateModel(context, plugins);
       writeFileSync3(modelHashPath, inputFilesHash);
@@ -694,9 +750,72 @@ async function buildOnce(config, userConfig, plugins, options) {
   }
   return ok2(succeeded);
 }
+function resolveModelSpec(modelSpec) {
+  let inputVarNames;
+  let inputSpecs;
+  if (modelSpec.inputs.length > 0) {
+    const item = modelSpec.inputs[0];
+    if (typeof item === "string") {
+      inputVarNames = modelSpec.inputs;
+      inputSpecs = inputVarNames.map((varName) => {
+        return {
+          varName
+        };
+      });
+    } else {
+      inputSpecs = modelSpec.inputs;
+      inputVarNames = inputSpecs.map((spec) => spec.varName);
+    }
+  } else {
+    inputVarNames = [];
+    inputSpecs = [];
+  }
+  let outputVarNames;
+  let outputSpecs;
+  if (modelSpec.outputs.length > 0) {
+    const item = modelSpec.outputs[0];
+    if (typeof item === "string") {
+      outputVarNames = modelSpec.outputs;
+      outputSpecs = outputVarNames.map((varName) => {
+        return {
+          varName
+        };
+      });
+    } else {
+      outputSpecs = modelSpec.outputs;
+      outputVarNames = outputSpecs.map((spec) => spec.varName);
+    }
+  } else {
+    outputVarNames = [];
+    outputSpecs = [];
+  }
+  let customLookups;
+  if (modelSpec.customLookups !== void 0) {
+    customLookups = modelSpec.customLookups;
+  } else {
+    customLookups = false;
+  }
+  let customOutputs;
+  if (modelSpec.customOutputs !== void 0) {
+    customOutputs = modelSpec.customOutputs;
+  } else {
+    customOutputs = false;
+  }
+  return {
+    inputVarNames,
+    inputs: inputSpecs,
+    outputVarNames,
+    outputs: outputSpecs,
+    datFiles: modelSpec.datFiles || [],
+    bundleListing: modelSpec.bundleListing === true,
+    customLookups,
+    customOutputs,
+    options: modelSpec.options
+  };
+}
 
 // src/build/impl/watch.ts
-import { basename } from "path";
+import { basename as basename2 } from "path";
 import chokidar from "chokidar";
 var BuildState = class {
   constructor() {
@@ -710,7 +829,7 @@ function watch(config, userConfig, plugins) {
   function performBuild() {
     clearOverlay();
     for (const path of changedPaths) {
-      log("info", `Input file ${basename(path)} has been changed`);
+      log("info", `Input file ${basename2(path)} has been changed`);
     }
     changedPaths.clear();
     if (currentBuildState) {
@@ -773,28 +892,27 @@ async function build(mode, options) {
   const messagesPath = joinPath6(resolvedConfig.prepDir, "messages.html");
   const overlayEnabled2 = mode === "development";
   setOverlayFile(messagesPath, overlayEnabled2);
-  const plugins = userConfig.plugins || [];
-  for (const plugin of plugins) {
-    if (plugin.init) {
-      await plugin.init(resolvedConfig);
-    }
-  }
   try {
-    const plugins2 = userConfig.plugins || [];
+    const plugins = userConfig.plugins || [];
+    for (const plugin of plugins) {
+      if (plugin.init) {
+        await plugin.init(resolvedConfig);
+      }
+    }
     if (mode === "development") {
-      const buildResult = await buildOnce(resolvedConfig, userConfig, plugins2, {});
+      const buildResult = await buildOnce(resolvedConfig, userConfig, plugins, {});
       if (buildResult.isErr()) {
         return err3(buildResult.error);
       }
-      for (const plugin of plugins2) {
+      for (const plugin of plugins) {
         if (plugin.watch) {
           await plugin.watch(resolvedConfig);
         }
       }
-      watch(resolvedConfig, userConfig, plugins2);
+      watch(resolvedConfig, userConfig, plugins);
       return ok3({});
     } else {
-      const buildResult = await buildOnce(resolvedConfig, userConfig, plugins2, {});
+      const buildResult = await buildOnce(resolvedConfig, userConfig, plugins, {});
       if (buildResult.isErr()) {
         return err3(buildResult.error);
       }