@sdeverywhere/build 0.3.3 → 0.3.5

package/dist/index.cjs

@@ -121,6 +121,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 ((0, import_path.isAbsolute)(userConfig.outListingFile)) {
+      outListingFile = userConfig.outListingFile;
+    } else {
+      outListingFile = (0, import_path.resolve)(rootDir, userConfig.outListingFile);
+    }
+  }
   return {
     mode,
     rootDir,
@@ -128,6 +148,8 @@ function resolveUserConfig(userConfig, mode, sdeDir, sdeCmdPath) {
     modelFiles,
     modelInputPaths,
     watchPaths,
+    genFormat,
+    outListingFile,
     sdeDir,
     sdeCmdPath
   };
@@ -545,18 +567,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 = (0, import_path3.join)(prepDir, "build", generatedCodeFile);
   for (const plugin of plugins) {
-    if (plugin.postGenerateC) {
-      const cPath = (0, import_path3.join)(prepDir, "build", "processed.c");
-      let cContent = await (0, import_promises.readFile)(cPath, "utf8");
-      cContent = await plugin.postGenerateC(context, cContent);
-      await (0, import_promises.writeFile)(cPath, cContent);
-    }
+    if (plugin.postGenerateCode) {
+      let generatedCodeContent = await (0, import_promises.readFile)(generatedCodePath, "utf8");
+      generatedCodeContent = await plugin.postGenerateCode(context, config.genFormat, generatedCodeContent);
+      await (0, import_promises.writeFile)(generatedCodePath, generatedCodeContent);
+    }
+  }
+  if (config.genFormat === "js") {
+    const outputJsFile = "generated-model.js";
+    const stagedOutputJsPath = context.prepareStagedFile("model", outputJsFile, prepDir, outputJsFile);
+    await (0, import_promises.copyFile)(generatedCodePath, stagedOutputJsPath);
+  }
+  if (config.outListingFile) {
+    const srcListingJsonPath = (0, import_path3.join)(prepDir, "build", "processed.json");
+    const stagedDir = "model";
+    const stagedFile = "listing.json";
+    const dstDir = (0, import_path3.dirname)(config.outListingFile);
+    const dstFile = (0, import_path3.basename)(config.outListingFile);
+    const stagedListingJsonPath = context.prepareStagedFile(stagedDir, stagedFile, dstDir, dstFile);
+    await (0, import_promises.copyFile)(srcListingJsonPath, stagedListingJsonPath);
   }
   const t1 = performance.now();
   const elapsed = ((t1 - t0) / 1e3).toFixed(1);
@@ -567,7 +604,14 @@ async function preprocessMdl(context, sdeCmdPath, prepDir, modelFile) {
   await (0, import_promises.copyFile)(modelFile, (0, import_path3.join)(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 (0, import_promises.copyFile)((0, import_path3.join)(prepDir, "build", "processed.mdl"), (0, import_path3.join)(prepDir, "processed.mdl"));
 }
 async function flattenMdls(context, sdeCmdPath, prepDir, modelFiles) {
@@ -600,31 +644,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 (0, import_promises.copyFile)((0, import_path3.join)(prepDir, "build", "processed.mdl"), (0, import_path3.join)(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 = (0, import_path3.join)(prepDir, "build");
-  const sdeCDir = (0, import_path3.join)(sdeDir, "src", "c");
-  const files = await (0, import_promises.readdir)(sdeCDir);
-  const copyOps = [];
-  for (const file of files) {
-    if (file.endsWith(".c") || file.endsWith(".h")) {
-      copyOps.push((0, import_promises.copyFile)((0, import_path3.join)(sdeCDir, file), (0, import_path3.join)(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 = (0, import_path3.join)(prepDir, "build");
+    const sdeCDir = (0, import_path3.join)(sdeDir, "src", "c");
+    const files = await (0, import_promises.readdir)(sdeCDir);
+    const copyOps = [];
+    for (const file of files) {
+      if (file.endsWith(".c") || file.endsWith(".h")) {
+        copyOps.push((0, import_promises.copyFile)((0, import_path3.join)(sdeCDir, file), (0, import_path3.join)(buildDir, file)));
+      }
     }
+    await Promise.all(copyOps);
   }
-  await Promise.all(copyOps);
 }
 
 // src/build/impl/hash-files.ts
@@ -659,45 +716,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 = (0, import_path5.join)(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 (0, import_neverthrow2.err)(new Error("The model spec must be defined"));
     }
-  } catch (e) {
-    return (0, import_neverthrow2.err)(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 = (0, import_path5.join)(config.prepDir, "spec.json");
+    await (0, import_promises2.writeFile)(specPath, JSON.stringify(specJson, null, 2));
+    let previousModelHash;
+    if ((0, import_fs4.existsSync)(modelHashPath)) {
+      previousModelHash = (0, import_fs4.readFileSync)(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 = (0, import_path5.join)(config.prepDir, "spec.json");
-  await (0, import_promises2.writeFile)(specPath, JSON.stringify(specJson, null, 2));
-  const modelHashPath = (0, import_path5.join)(config.prepDir, "model-hash.txt");
-  let previousModelHash;
-  if ((0, import_fs4.existsSync)(modelHashPath)) {
-    previousModelHash = (0, import_fs4.readFileSync)(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);
       (0, import_fs4.writeFileSync)(modelHashPath, inputFilesHash);
@@ -733,6 +789,69 @@ async function buildOnce(config, userConfig, plugins, options) {
   }
   return (0, import_neverthrow2.ok)(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
 var import_path6 = require("path");
@@ -812,28 +931,27 @@ async function build(mode, options) {
   const messagesPath = (0, import_path7.join)(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 (0, import_neverthrow3.err)(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 (0, import_neverthrow3.ok)({});
     } else {
-      const buildResult = await buildOnce(resolvedConfig, userConfig, plugins2, {});
+      const buildResult = await buildOnce(resolvedConfig, userConfig, plugins, {});
       if (buildResult.isErr()) {
         return (0, import_neverthrow3.err)(buildResult.error);
       }