geomcli 0.5.13 → 0.5.15

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { tGeomFunc, tParamVal, EFormat, tAllPageDef } from 'geometrix';
+
+declare function geom_write(iPartName: string, fgeom: tGeomFunc, simTime: number, iParam: tParamVal, iFormat: EFormat, iFace?: string, iDir?: string, iFname?: string): Promise<string>;
+
+declare function geom_cli(iArgs: string[], dList: tAllPageDef, outDir?: string): Promise<void>;
+
+export { geom_cli, geom_write };

package/dist/index.js

@@ -0,0 +1,595 @@
+// src/geom_write.ts
+import {
+  fileBinContent,
+  fileTextContent,
+  fileSuffix,
+  fileBin,
+  createParamFile,
+  parseParamFile
+} from "geometrix";
+import fs from "fs";
+function dateString() {
+  const re1 = /[-:]/g;
+  const re2 = /\..*$/;
+  const rDateStr = (/* @__PURE__ */ new Date()).toISOString().replace(re1, "").replace(re2, "").replace("T", "_");
+  return rDateStr;
+}
+function createDir(iDir) {
+  let rlog = "";
+  if (!fs.existsSync(iDir)) {
+    fs.mkdirSync(iDir, { recursive: true });
+    rlog += `info203: mkdir ${iDir}
+`;
+  }
+  return rlog;
+}
+async function write_binFile(fName, fContent) {
+  let rlog = "";
+  const buffer = await fContent.arrayBuffer();
+  const arrBufView = new DataView(buffer);
+  fs.writeFileSync(fName, arrBufView);
+  rlog += `info304: bin-file ${fName} has been written
+`;
+  return rlog;
+}
+function write_textFile(fName, fContent) {
+  let rlog = "";
+  fs.writeFileSync(fName, fContent);
+  rlog += `info405: text-file ${fName} has been written
+`;
+  return rlog;
+}
+function checkDirFName(iDir, fName) {
+  const reSlash = /\//;
+  if (reSlash.test(fName)) {
+    throw `err932: the filename ${fName} contains a slash '/'`;
+  }
+  if (iDir === "") {
+    throw `err074: geom_write output-directory is an empty string!`;
+  }
+  const fName2 = `${iDir}/${fName}`;
+  return fName2;
+}
+function writeParams(iPartName, idparams, oDir, oFileName) {
+  const re1 = /[-:]/g;
+  const re2 = /\..*$/;
+  const datestr = (/* @__PURE__ */ new Date()).toISOString().replace(re1, "").replace(re2, "").replace("T", "_");
+  let file_name = `px_${iPartName}_${datestr}.json`;
+  if (oFileName !== "") {
+    file_name = oFileName;
+  }
+  const paramNb = Object.keys(idparams).length;
+  const fName2 = checkDirFName(oDir, file_name);
+  let rlog = `Write ${paramNb} parameters in file ${fName2}
+`;
+  const file_content = createParamFile(datestr, idparams, "Written by geom_cli");
+  rlog += createDir(oDir);
+  write_textFile(fName2, file_content);
+  return rlog;
+}
+function readParams(paramPath, printLog) {
+  let rParamVal = {};
+  if (paramPath !== "") {
+    let rlog = `Read parameter file ${paramPath}
+`;
+    if (!fs.existsSync(paramPath)) {
+      throw `err533: file ${paramPath} doesn't exist!`;
+    }
+    const fContentStr = fs.readFileSync(paramPath, "utf8");
+    const [obj] = parseParamFile(fContentStr);
+    rlog += `file lastModif: ${obj.lastModif}
+`;
+    rlog += `file comment: ${obj.comment}
+`;
+    rlog += `info307: ${Object.keys(obj.pVal).length} parameters from file`;
+    rParamVal = obj.pVal;
+    if (printLog) {
+      console.log(rlog);
+    }
+  }
+  return rParamVal;
+}
+async function geom_write(iPartName, fgeom, simTime, iParam, iFormat, iFace = "", iDir = ".", iFname = "") {
+  let rlog = "";
+  const fSuffix = fileSuffix(iFormat);
+  const fBin = fileBin(iFormat);
+  let nFace = "all";
+  if (iFace !== "") {
+    nFace = iFace;
+  }
+  let fName = iFname;
+  if (fName === "") {
+    fName = iPartName + "_" + nFace + "_" + dateString() + fSuffix;
+  }
+  const fName2 = checkDirFName(iDir, fName);
+  rlog += createDir(iDir);
+  if (fBin) {
+    const fContent = await fileBinContent(fgeom, simTime, iParam, iFormat);
+    rlog += await write_binFile(fName2, fContent);
+  } else {
+    const fContent = fileTextContent(fgeom, iParam, nFace, iFormat);
+    rlog += write_textFile(fName2, fContent);
+  }
+  return rlog;
+}
+
+// src/geom_cli.ts
+import { PType, EFormat as EFormat2, designParam, prefixLog, paramListToVal } from "geometrix";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// package.json
+var version = "0.5.15";
+
+// src/geom_cli.ts
+function get_design_array(dList) {
+  const rDesignArray = Object.keys(dList);
+  return rDesignArray;
+}
+function selectDesign(dList, selD) {
+  if (!Object.keys(dList).includes(selD)) {
+    console.log(`err918: design ${selD} is not defined`);
+    process.exit(1);
+  }
+  return dList[selD];
+}
+function selectDesignN(dList, selD) {
+  const theD = selectDesign(dList, selD);
+  const dName = theD.pDef.partName;
+  return dName;
+}
+function parseModif(modif, printLog) {
+  const pVal = {};
+  const arrayLen = modif.length;
+  if (arrayLen % 2 === 1) {
+    throw `err903: length ${arrayLen} of modif string array is odd!`;
+  }
+  for (let i = 0; i < arrayLen / 2; i++) {
+    const valStr = modif[2 * i + 1];
+    const val = parseFloat(valStr);
+    if (isNaN(val)) {
+      throw `err908: ${valStr} is not a number!`;
+    }
+    pVal[modif[2 * i]] = val;
+  }
+  const pValLen = Object.keys(pVal).length;
+  if (printLog && pValLen > 0) {
+    const rlog = `info308: ${pValLen} parameters of modifier`;
+    console.log(rlog);
+  }
+  return pVal;
+}
+function computeGeom(dList, selD, paramPath, modif, printLog) {
+  const theD = selectDesign(dList, selD);
+  let rlog = `Compute design ${selD} (${theD.pDef.partName}):
+`;
+  const dParam = designParam(theD.pDef);
+  try {
+    dParam.applyParamVal(readParams(paramPath, printLog));
+    dParam.applyParamVal(parseModif(modif, printLog));
+  } catch (emsg) {
+    console.log("err271: error while applying new parameters");
+    console.log(emsg);
+    process.exit(1);
+  }
+  const simtime = 0;
+  const dGeom = theD.pGeom(simtime, dParam.getParamVal());
+  rlog += prefixLog(dGeom.logstr, dParam.partName);
+  if (dGeom.calcErr) {
+    rlog += `err907: Error while computing ${theD.pDef.partName}
+`;
+    console.log(rlog);
+    process.exit(1);
+  } else {
+    rlog += `${theD.pDef.partName} successfully computed
+`;
+  }
+  if (printLog) {
+    console.log(rlog);
+  }
+  return dGeom;
+}
+function get_figure_array(dList, selD, paramPath, modif) {
+  const dGeom = computeGeom(dList, selD, paramPath, modif, false);
+  const rfigN = Object.keys(dGeom.fig);
+  return rfigN;
+}
+function get_subdesign_array(dList, selD, paramPath, modif) {
+  const dGeom = computeGeom(dList, selD, paramPath, modif, false);
+  const subd = dGeom.sub;
+  return subd;
+}
+function get_subd(dList, selD, subdN, paramPath, modif, printLog) {
+  const theD = selectDesign(dList, selD);
+  const dGeom = computeGeom(dList, selD, paramPath, modif, printLog);
+  if (!Object.keys(dGeom.sub).includes(subdN)) {
+    console.log(`err207: sub-design ${subdN} not defined in partName ${theD.pDef.partName}`);
+    process.exit(1);
+  }
+  const rSubd = dGeom.sub[subdN];
+  if (printLog) {
+    const rlog = `Subdesign ${subdN} (${rSubd.partName}) of ${selD} (${theD.pDef.partName}):
+`;
+    console.log(rlog);
+  }
+  return rSubd;
+}
+var c_fileFormat = [
+  "json_param",
+  "svg_all_figures",
+  "dxf_all_figures",
+  "pax_all",
+  "scad_3d_openscad",
+  "js_3d_openjscad",
+  "zip_all"
+];
+function get_outopt_array(dList, selD, paramPath, modif) {
+  const rOutOpt = [];
+  const figN = get_figure_array(dList, selD, paramPath, modif);
+  const subdN = Object.keys(get_subdesign_array(dList, selD, paramPath, modif));
+  for (const figNi of figN) {
+    rOutOpt.push(`svg__${figNi}`);
+  }
+  for (const figNi of figN) {
+    rOutOpt.push(`dxf__${figNi}`);
+  }
+  for (const subdNi of subdN) {
+    rOutOpt.push(`json_sub_param_${subdNi}`);
+  }
+  for (const ffi of c_fileFormat) {
+    rOutOpt.push(`${ffi}`);
+  }
+  return rOutOpt;
+}
+function decompose_outopt(outopt) {
+  let rWrite = 2 /* eOTHERS */;
+  let rFormat = EFormat2.ePAX;
+  let rFace = "all";
+  let rSubD = "";
+  const reSvg = /^svg__/;
+  const reDxf = /^dxf__/;
+  const reSubP = /^json_sub_param_/;
+  if (outopt.match(reSvg)) {
+    rFace = outopt.replace(reSvg, "");
+    rFormat = EFormat2.eSVG;
+    rWrite = 2 /* eOTHERS */;
+  } else if (outopt.match(reDxf)) {
+    rFace = outopt.replace(reDxf, "");
+    rFormat = EFormat2.eDXF;
+    rWrite = 2 /* eOTHERS */;
+  } else if (outopt.match(reSubP)) {
+    rSubD = outopt.replace(reSubP, "");
+    rWrite = 1 /* eSUBDPARAMS */;
+  } else {
+    switch (outopt) {
+      case "json_param":
+        rWrite = 0 /* eEGOPARAMS */;
+        break;
+      case "svg_all_figures":
+        rFormat = EFormat2.eSVGALL;
+        rWrite = 2 /* eOTHERS */;
+        break;
+      case "dxf_all_figures":
+        rFormat = EFormat2.eDXFALL;
+        rWrite = 2 /* eOTHERS */;
+        break;
+      case "pax_all":
+        rFormat = EFormat2.ePAX;
+        rWrite = 2 /* eOTHERS */;
+        break;
+      case "scad_3d_openscad":
+        rFormat = EFormat2.eOPENSCAD;
+        rWrite = 2 /* eOTHERS */;
+        break;
+      case "js_3d_openjscad":
+        rFormat = EFormat2.eJSCAD;
+        rWrite = 2 /* eOTHERS */;
+        break;
+      case "zip_all":
+        rFormat = EFormat2.eZIP;
+        rWrite = 2 /* eOTHERS */;
+        break;
+      default:
+        rFormat = EFormat2.ePAX;
+        rWrite = 2 /* eOTHERS */;
+    }
+  }
+  const eFormat = { eWrite: rWrite, eFormat: rFormat, eFace: rFace, eSubdesign: rSubD };
+  return eFormat;
+}
+function list_designs(dList, detail) {
+  let rlog = "List of available designs:\n";
+  for (const [idx, dname] of get_design_array(dList).entries()) {
+    rlog += `${(idx + 1).toString().padStart(4, " ")} : ${dname}
+`;
+    if (detail) {
+      rlog += `        ${dList[dname].pDef.partName}
+`;
+      rlog += `        ${dList[dname].pTitle}
+`;
+      rlog += `        ${dList[dname].pDescription}
+`;
+    }
+  }
+  console.log(rlog);
+}
+function list_parameters(dList, selD, paramPath, modif) {
+  const theD = selectDesign(dList, selD);
+  let rlog = `List of parameters of the design ${selD} (${theD.pDef.partName}):
+`;
+  const dParam = designParam(theD.pDef);
+  try {
+    dParam.applyParamVal(readParams(paramPath, true));
+    dParam.applyParamVal(parseModif(modif, true));
+  } catch (emsg) {
+    console.log("err272: error while applying new parameters");
+    console.log(emsg);
+    process.exit(1);
+  }
+  const paramVal = dParam.getParamVal();
+  const nameLength = 20;
+  const unitLength = 8;
+  const nameLabel = "name".padEnd(nameLength, " ");
+  const unitLabel = "unit".padEnd(unitLength, " ");
+  rlog += `   # : ${nameLabel} current ${unitLabel} init   min max step
+`;
+  for (const [idx, pa] of theD.pDef.params.entries()) {
+    const idx2 = (idx + 1).toString().padStart(4, " ");
+    const pname = pa.name.padEnd(nameLength, " ");
+    const pcurr = paramVal[pa.name];
+    const pcurrP = pcurr.toString().padStart(6, " ");
+    const punit = pa.unit.padEnd(unitLength, " ");
+    const pinit = pa.init.toString().padStart(6, " ");
+    switch (pa.pType) {
+      case PType.eCheckbox:
+        rlog += `${idx2} : ${pname} checkbox ${pcurr}   ${pa.init}
+`;
+        break;
+      case PType.eDropdown:
+        rlog += `${idx2} : ${pname} ${pcurr}   ${pa.init}`;
+        for (const [optI, optN] of pa.dropdown.entries()) {
+          rlog += ` ${optI}:${optN}`;
+        }
+        rlog += "\n";
+        break;
+      default:
+        rlog += `${idx2} : ${pname} ${pcurrP} ${punit} ${pinit}   ${pa.min} ${pa.max} ${pa.step}
+`;
+    }
+  }
+  console.log(rlog);
+}
+function list_figures(dList, selD, paramPath, modif) {
+  const dPartName = selectDesignN(dList, selD);
+  const figN = get_figure_array(dList, selD, paramPath, modif);
+  let rlog = `List of figures of the design ${selD} (${dPartName}):
+`;
+  for (const [idx, figNi] of figN.entries()) {
+    const idx2 = (idx + 1).toString().padStart(4, " ");
+    rlog += `${idx2} : ${figNi}
+`;
+  }
+  console.log(rlog);
+}
+function list_subdesigns(dList, selD, paramPath, modif) {
+  const dPartName = selectDesignN(dList, selD);
+  const subdA = get_subdesign_array(dList, selD, paramPath, modif);
+  const subdN = Object.keys(subdA);
+  let rlog = `List of sub-designs of the design ${selD} (${dPartName}):
+`;
+  for (const [idx, subdNi] of subdN.entries()) {
+    const idx2 = (idx + 1).toString().padStart(4, " ");
+    const subd = subdA[subdNi];
+    const ori = `[ ${subd.orientation[0]}, ${subd.orientation[1]}, ${subd.orientation[2]}]`;
+    const pos = `[ ${subd.position[0]}, ${subd.position[1]}, ${subd.position[2]}]`;
+    const subdNp = subdNi.padEnd(15, " ");
+    const subdPp = subd.partName.padEnd(15, " ");
+    rlog += `${idx2} : ${subdNp} ${subdPp}   orientation: ${ori}  position: ${pos}
+`;
+  }
+  console.log(rlog);
+}
+function list_subd_parameters(dList, selD, subdN, paramPath, modif) {
+  const subdParam = get_subd(dList, selD, subdN, paramPath, modif, true).dparam;
+  const nameLength = 20;
+  const nameLabel = "name".padEnd(nameLength, " ");
+  let rlog = `   # : ${nameLabel} value init changed
+`;
+  for (const [idx, ipaN] of Object.keys(subdParam).entries()) {
+    const idx2 = (idx + 1).toString().padStart(4, " ");
+    const paN = ipaN.padEnd(nameLength, " ");
+    const pa = subdParam[ipaN];
+    const paVal = pa.val.toString().padStart(6, " ");
+    const paInit = pa.init.toString().padStart(6, " ");
+    rlog += `${idx2} : ${paN} ${paVal} ${paInit} ${pa.chg ? "changed" : ""}
+`;
+  }
+  console.log(rlog);
+}
+function list_outopt(dList, selD, paramPath, modif) {
+  const dPartName = selectDesignN(dList, selD);
+  let rlog = `List of outputs of the design ${selD} (${dPartName}):
+`;
+  const outOpt = get_outopt_array(dList, selD, paramPath, modif);
+  for (const [idx, oneOpt] of outOpt.entries()) {
+    const idx2 = (idx + 1).toString().padStart(4, " ");
+    rlog += `${idx2} : ${oneOpt}
+`;
+  }
+  console.log(rlog);
+}
+var cmd_write = false;
+async function geom_cli(iArgs, dList, outDir = "output") {
+  const argv = yargs(hideBin(iArgs)).scriptName("geom_cli").version(version).usage("Usage: $0 <global-options> command <command-argument>").example([
+    ["$0 list-designs", "list the available designs"],
+    ["$0 list-designs-detailed", "list the available designs with detailed information"],
+    ["$0 -d heliostat/rake compute-log", "compute and print the log"],
+    ["$0 -d heliostat/swing list-outopt", "list possible output-format-options"],
+    ["$0 -d heliostat/rod write zip_all", "write a zip file"]
+  ]).option("design", {
+    alias: "d",
+    type: "string",
+    description: "design to be used by the command",
+    default: ""
+  }).option("param", {
+    alias: "p",
+    type: "string",
+    array: false,
+    description: "path to the input parameter file",
+    default: ""
+  }).option("modif", {
+    alias: "m",
+    nargs: 2,
+    type: "string",
+    description: "modify parameter values <paramName> <paramValue>",
+    default: ""
+  }).option("outDir", {
+    alias: "o",
+    type: "string",
+    description: "the path of the directory where to write the output files",
+    default: outDir
+  }).option("outFileName", {
+    type: "string",
+    description: "Rename the output filename",
+    default: ""
+  }).command(["list-designs", "list"], "list the available designs", {}, () => {
+    list_designs(dList, false);
+  }).command("list-designs-detailed", "list the available designs with details", {}, () => {
+    list_designs(dList, true);
+  }).command("list-parameters", "list the parameters of the selected design", {}, (argv2) => {
+    list_parameters(
+      dList,
+      argv2.design,
+      argv2.param,
+      argv2.modif
+    );
+  }).command("list-figures", "list the figures of the selected design", {}, (argv2) => {
+    list_figures(
+      dList,
+      argv2.design,
+      argv2.param,
+      argv2.modif
+    );
+  }).command("list-subdesigns", "list the subdesigns of the selected design", {}, (argv2) => {
+    list_subdesigns(
+      dList,
+      argv2.design,
+      argv2.param,
+      argv2.modif
+    );
+  }).command(
+    "list-subd-parameters <subdN>",
+    "list the parameters of subdesigns",
+    {},
+    (argv2) => {
+      list_subd_parameters(
+        dList,
+        argv2.design,
+        argv2.subdN,
+        argv2.param,
+        argv2.modif
+      );
+    }
+  ).command("compute-log", "Compute and print the log without writing file", {}, (argv2) => {
+    computeGeom(
+      dList,
+      argv2.design,
+      argv2.param,
+      argv2.modif,
+      true
+    );
+  }).command(
+    "list-outopt",
+    "list the possible output format options of the selected design",
+    {},
+    (argv2) => {
+      list_outopt(
+        dList,
+        argv2.design,
+        argv2.param,
+        argv2.modif
+      );
+    }
+  ).command("write <outopt>", "write the output format file", {}, () => {
+    cmd_write = true;
+  }).demandCommand(1).help().strict().parseSync();
+  if (cmd_write) {
+    const iOutDir = argv.outDir;
+    if (iOutDir === "") {
+      console.log("err638: option 'outDir' is set to empty string. Nothing written!");
+      process.exit(1);
+    }
+    const selD = argv.design;
+    const outopt = argv.outopt;
+    const paramPath = argv.param;
+    const paramModif = argv.modif;
+    const theD = selectDesign(dList, selD);
+    const outOpt = get_outopt_array(dList, selD, paramPath, paramModif);
+    if (!outOpt.includes(outopt)) {
+      console.log(`err639: outopt ${outopt} is not a valid option`);
+      process.exit(1);
+    }
+    let rlog = "";
+    const oOpt = decompose_outopt(outopt);
+    const dParam = designParam(theD.pDef);
+    try {
+      dParam.applyParamVal(readParams(paramPath, false));
+      dParam.applyParamVal(parseModif(paramModif, false));
+    } catch (emsg) {
+      console.log("err273: error while applying new parameters");
+      console.log(emsg);
+      process.exit(1);
+    }
+    computeGeom(dList, selD, paramPath, paramModif, true);
+    try {
+      if (oOpt.eWrite === 0 /* eEGOPARAMS */) {
+        rlog += writeParams(
+          dParam.partName,
+          dParam.getParamVal(),
+          iOutDir,
+          argv.outFileName
+        );
+      } else if (oOpt.eWrite === 1 /* eSUBDPARAMS */) {
+        const subD = get_subd(dList, selD, oOpt.eSubdesign, paramPath, paramModif, false);
+        rlog += writeParams(
+          subD.partName,
+          paramListToVal(subD.dparam),
+          iOutDir,
+          argv.outFileName
+        );
+      } else {
+        const simtime = 0;
+        rlog += await geom_write(
+          dParam.partName,
+          theD.pGeom,
+          simtime,
+          dParam.getParamVal(),
+          oOpt.eFormat,
+          // output-format
+          //EFormat.eSVG,
+          //EFormat.eDXF,
+          //EFormat.ePAX,
+          //EFormat.eOPENSCAD,
+          //EFormat.eJSCAD,
+          //EFormat.eZIP,
+          oOpt.eFace,
+          // selected-2d-face
+          iOutDir,
+          // output-directory
+          argv.outFileName
+          // output-filename
+        );
+      }
+    } catch (emsg) {
+      console.log("err279: error while writing file");
+      console.log(emsg);
+      process.exit(1);
+    }
+    console.log(rlog);
+  }
+}
+export {
+  geom_cli,
+  geom_write
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "geomcli",
-	"version": "0.5.13",
+	"version": "0.5.15",
 	"description": "the nodejs companion library of geometrix",
 	"private": false,
 	"repository": {
@@ -63,6 +63,12 @@
 			"default": "./dist/index.js"
 		}
 	},
+	"files": [
+		"dist",
+		"!dist/**/*.map",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
 	"types": "./dist/index.d.ts",
 	"type": "module"
 }

package/.eslintignore

@@ -1,17 +0,0 @@
-.DS_Store
-node_modules
-/build
-/.svelte-kit
-/package
-.env
-.env.*
-!.env.example
-
-# Ignore files for PNPM, NPM and YARN
-pnpm-lock.yaml
-package-lock.json
-yarn.lock
-
-# ignore recommended by eslint
-vitest.config.ts
-dist/

package/.eslintrc.cjs

@@ -1,24 +0,0 @@
-module.exports = {
-	extends: [
-		'eslint:recommended',
-		'plugin:@typescript-eslint/recommended-type-checked',
-		//'plugin:@typescript-eslint/strict-type-checked',
-		'plugin:@typescript-eslint/stylistic-type-checked',
-		'prettier'
-	],
-	plugins: ['@typescript-eslint'],
-	parser: '@typescript-eslint/parser',
-	parserOptions: {
-		//sourceType: 'module',
-		//ecmaVersion: 2020,
-		project: true,
-		tsconfigRootDir: __dirname
-	},
-	root: true
-	//env: {
-	//	browser: true,
-	//	es2021: true,
-	//	node: true
-	//},
-	//ignorePatterns: ['*.cjs'],
-};

package/.prettierignore

@@ -1,15 +0,0 @@
-.DS_Store
-node_modules
-/build
-/dist
-/.svelte-kit
-/package
-.env
-.env.*
-!.env.example
-README.md
-
-# Ignore files for PNPM, NPM and YARN
-pnpm-lock.yaml
-package-lock.json
-yarn.lock

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"printWidth": 100,
-	"plugins": [],
-	"overrides": []
-}