geomcli 0.5.5

package/.eslintignore

@@ -0,0 +1,17 @@
+.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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,15 @@
+.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

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

package/README.md

@@ -0,0 +1,23 @@
+README of geomcli
+=================
+
+
+Presentation
+------------
+
+*geomcli* is the companion *typescript* library of *geometrix* for creating *nodejs* script or *cli*.
+
+Getting started
+---------------
+
+```bash
+git clone https://github.com/charlyoleg2/parametrix
+cd parametrix
+npm install
+npm ci
+npm -w design-script run run
+```
+
+
+
+

package/package.json

@@ -0,0 +1,68 @@
+{
+	"name": "geomcli",
+	"version": "0.5.5",
+	"description": "the nodejs companion library of geometrix",
+	"private": false,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/charlyoleg2/parametrix.git"
+	},
+	"homepage": "https://github.com/charlyoleg2/parametrix#readme",
+	"keywords": [
+		"cad",
+		"programmatic",
+		"2D",
+		"circle",
+		"stroke",
+		"arc",
+		"gear"
+	],
+	"author": "charlyoleg",
+	"tsup": {
+		"entry": [
+			"src/index.ts"
+		],
+		"format": "esm",
+		"splitting": false,
+		"dts": true,
+		"sourcemap": true,
+		"clean": true
+	},
+	"scripts": {
+		"dev": "tsup --watch",
+		"build": "tsup",
+		"check": "tsc --noEmit",
+		"pretty": "prettier --check .",
+		"format": "prettier --write .",
+		"lint": "eslint .",
+		"test:unit": "vitest",
+		"test:unit:once": "vitest --run",
+		"ci": "run-s check build pretty lint test:unit:once",
+		"clean": "shx rm -fr build dist node_modules"
+	},
+	"dependencies": {
+		"geometrix": "^0.5.1",
+		"yargs": "^17.7.2"
+	},
+	"devDependencies": {
+		"@types/yargs": "^17.0.32",
+		"@typescript-eslint/eslint-plugin": "^6.16.0",
+		"@typescript-eslint/parser": "^6.16.0",
+		"eslint": "^8.56.0",
+		"eslint-config-prettier": "^9.1.0",
+		"npm-run-all": "^4.1.5",
+		"prettier": "^3.1.1",
+		"shx": "^0.3.4",
+		"tsup": "^8.0.1",
+		"typescript": "^5.3.3",
+		"vitest": "^1.1.0"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"types": "dist/index.d.ts",
+	"type": "module"
+}

package/src/geom_cli.ts

@@ -0,0 +1,550 @@
+// geom_cli.ts
+
+import type { tParamVal, tGeom, tSubDesign, tPageDef, tAllPageDef, tSubInst } from 'geometrix';
+import { PType, EFormat, designParam, prefixLog, paramListToVal } from 'geometrix';
+import { geom_write, writeParams, readParams } from './geom_write';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { version } from '../package.json';
+
+function get_design_array(dList: tAllPageDef): string[] {
+	const rDesignArray = Object.keys(dList);
+	return rDesignArray;
+}
+
+function selectDesign(dList: tAllPageDef, selD: string): tPageDef {
+	if (!Object.keys(dList).includes(selD)) {
+		console.log(`err918: design ${selD} is not defined`);
+		process.exit(1);
+	}
+	return dList[selD];
+}
+
+function selectDesignN(dList: tAllPageDef, selD: string): string {
+	const theD = selectDesign(dList, selD);
+	const dName = theD.pDef.partName;
+	return dName;
+}
+
+function parseModif(modif: string[], printLog: boolean): tParamVal {
+	const pVal: tParamVal = {};
+	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: tAllPageDef,
+	selD: string,
+	paramPath: string,
+	modif: string[],
+	printLog: boolean
+): tGeom {
+	const theD = selectDesign(dList, selD);
+	let rlog = `Compute design ${selD} (${theD.pDef.partName}):\n`;
+	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());
+	//checkGeom(dGeom);
+	rlog += prefixLog(dGeom.logstr, dParam.partName);
+	if (dGeom.calcErr) {
+		rlog += `err907: Error while computing ${theD.pDef.partName}\n`;
+		console.log(rlog);
+		process.exit(1);
+	} else {
+		rlog += `${theD.pDef.partName} successfully computed\n`;
+	}
+	if (printLog) {
+		console.log(rlog);
+	}
+	return dGeom;
+}
+
+function get_figure_array(
+	dList: tAllPageDef,
+	selD: string,
+	paramPath: string,
+	modif: string[]
+): string[] {
+	const dGeom = computeGeom(dList, selD, paramPath, modif, false);
+	const rfigN = Object.keys(dGeom.fig);
+	return rfigN;
+}
+
+function get_subdesign_array(
+	dList: tAllPageDef,
+	selD: string,
+	paramPath: string,
+	modif: string[]
+): tSubDesign {
+	const dGeom = computeGeom(dList, selD, paramPath, modif, false);
+	const subd = dGeom.sub;
+	return subd;
+}
+
+function get_subd(
+	dList: tAllPageDef,
+	selD: string,
+	subdN: string,
+	paramPath: string,
+	modif: string[],
+	printLog: boolean
+): tSubInst {
+	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}):\n`;
+		console.log(rlog);
+	}
+	return rSubd;
+}
+
+const 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: tAllPageDef,
+	selD: string,
+	paramPath: string,
+	modif: string[]
+): string[] {
+	const rOutOpt: string[] = [];
+	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;
+}
+
+enum EWrite {
+	eEGOPARAMS,
+	eSUBDPARAMS,
+	eOTHERS
+}
+
+interface tEFormat {
+	eWrite: EWrite;
+	eFormat: EFormat;
+	eFace: string;
+	eSubdesign: string;
+}
+
+function decompose_outopt(outopt: string): tEFormat {
+	let rWrite = EWrite.eOTHERS;
+	let rFormat = EFormat.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 = EFormat.eSVG;
+		rWrite = EWrite.eOTHERS;
+	} else if (outopt.match(reDxf)) {
+		rFace = outopt.replace(reDxf, '');
+		rFormat = EFormat.eDXF;
+		rWrite = EWrite.eOTHERS;
+	} else if (outopt.match(reSubP)) {
+		rSubD = outopt.replace(reSubP, '');
+		rWrite = EWrite.eSUBDPARAMS;
+	} else {
+		switch (outopt) {
+			case 'json_param':
+				rWrite = EWrite.eEGOPARAMS;
+				break;
+			case 'svg_all_figures':
+				rFormat = EFormat.eSVGALL;
+				rWrite = EWrite.eOTHERS;
+				break;
+			case 'dxf_all_figures':
+				rFormat = EFormat.eDXFALL;
+				rWrite = EWrite.eOTHERS;
+				break;
+			case 'pax_all':
+				rFormat = EFormat.ePAX;
+				rWrite = EWrite.eOTHERS;
+				break;
+			case 'scad_3d_openscad':
+				rFormat = EFormat.eOPENSCAD;
+				rWrite = EWrite.eOTHERS;
+				break;
+			case 'js_3d_openjscad':
+				rFormat = EFormat.eJSCAD;
+				rWrite = EWrite.eOTHERS;
+				break;
+			case 'zip_all':
+				rFormat = EFormat.eZIP;
+				rWrite = EWrite.eOTHERS;
+				break;
+			default:
+				rFormat = EFormat.ePAX;
+				rWrite = EWrite.eOTHERS;
+		}
+	}
+	const eFormat: tEFormat = { eWrite: rWrite, eFormat: rFormat, eFace: rFace, eSubdesign: rSubD };
+	return eFormat;
+}
+
+function list_designs(dList: tAllPageDef, detail: boolean) {
+	let rlog = 'List of available designs:\n';
+	for (const [idx, dname] of get_design_array(dList).entries()) {
+		rlog += `${(idx + 1).toString().padStart(4, ' ')} : ${dname}\n`;
+		if (detail) {
+			rlog += `        ${dList[dname].pDef.partName}\n`;
+			rlog += `        ${dList[dname].pTitle}\n`;
+			rlog += `        ${dList[dname].pDescription}\n`;
+		}
+	}
+	console.log(rlog);
+}
+
+function list_parameters(dList: tAllPageDef, selD: string, paramPath: string, modif: string[]) {
+	const theD = selectDesign(dList, selD);
+	let rlog = `List of parameters of the design ${selD} (${theD.pDef.partName}):\n`;
+	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\n`;
+	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}\n`;
+				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}\n`;
+		}
+	}
+	console.log(rlog);
+}
+
+function list_figures(dList: tAllPageDef, selD: string, paramPath: string, modif: string[]) {
+	const dPartName = selectDesignN(dList, selD);
+	const figN = get_figure_array(dList, selD, paramPath, modif);
+	let rlog = `List of figures of the design ${selD} (${dPartName}):\n`;
+	for (const [idx, figNi] of figN.entries()) {
+		const idx2 = (idx + 1).toString().padStart(4, ' ');
+		rlog += `${idx2} : ${figNi}\n`;
+	}
+	console.log(rlog);
+}
+
+function list_subdesigns(dList: tAllPageDef, selD: string, paramPath: string, modif: string[]) {
+	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}):\n`;
+	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}\n`;
+	}
+	console.log(rlog);
+}
+
+function list_subd_parameters(
+	dList: tAllPageDef,
+	selD: string,
+	subdN: string,
+	paramPath: string,
+	modif: string[]
+) {
+	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\n`;
+	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' : ''}\n`;
+	}
+	console.log(rlog);
+}
+
+function list_outopt(dList: tAllPageDef, selD: string, paramPath: string, modif: string[]) {
+	const dPartName = selectDesignN(dList, selD);
+	let rlog = `List of outputs of the design ${selD} (${dPartName}):\n`;
+	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}\n`;
+	}
+	console.log(rlog);
+}
+
+let cmd_write = false;
+async function geom_cli(iArgs: string[], dList: tAllPageDef, 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', {}, (argv) => {
+			//console.log(argv)
+			list_parameters(
+				dList,
+				argv.design as string,
+				argv.param as string,
+				argv.modif as string[]
+			);
+		})
+		.command('list-figures', 'list the figures of the selected design', {}, (argv) => {
+			list_figures(
+				dList,
+				argv.design as string,
+				argv.param as string,
+				argv.modif as string[]
+			);
+		})
+		.command('list-subdesigns', 'list the subdesigns of the selected design', {}, (argv) => {
+			list_subdesigns(
+				dList,
+				argv.design as string,
+				argv.param as string,
+				argv.modif as string[]
+			);
+		})
+		.command(
+			'list-subd-parameters <subdN>',
+			'list the parameters of subdesigns',
+			{},
+			(argv) => {
+				list_subd_parameters(
+					dList,
+					argv.design as string,
+					argv.subdN as string,
+					argv.param as string,
+					argv.modif as string[]
+				);
+			}
+		)
+		.command('compute-log', 'Compute and print the log without writing file', {}, (argv) => {
+			computeGeom(
+				dList,
+				argv.design as string,
+				argv.param as string,
+				argv.modif as string[],
+				true
+			);
+		})
+		.command(
+			'list-outopt',
+			'list the possible output format options of the selected design',
+			{},
+			(argv) => {
+				list_outopt(
+					dList,
+					argv.design as string,
+					argv.param as string,
+					argv.modif as string[]
+				);
+			}
+		)
+		.command('write <outopt>', 'write the output format file', {}, () => {
+			cmd_write = true;
+		})
+		.demandCommand(1)
+		.help()
+		.strict()
+		.parseSync();
+	//console.log(argv.$0);
+	//console.log(argv.design);
+	//console.log(argv.param);
+	//console.log(argv.modif);
+	//console.log(argv.outDir);
+	//console.log(argv);
+	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 as string;
+		const paramPath = argv.param;
+		const paramModif = argv.modif as unknown as string[];
+		const theD = selectDesign(dList, selD);
+		// check if outopt is valid
+		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);
+		}
+		// end of check of outopt
+		//let rlog = `Write ${outopt} of ${selD} (${theD.pDef.partName}):\n`;
+		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 === EWrite.eEGOPARAMS) {
+				rlog += writeParams(
+					dParam.partName,
+					dParam.getParamVal(),
+					iOutDir,
+					argv.outFileName
+				);
+			} else if (oOpt.eWrite === EWrite.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 };

package/src/geom_write.ts

@@ -0,0 +1,136 @@
+// geom_write.ts
+
+import type { tGeomFunc, tParamVal } from 'geometrix';
+import {
+	EFormat,
+	fileBinContent,
+	fileTextContent,
+	fileSuffix,
+	fileBin,
+	createParamFile,
+	parseParamFile
+} from 'geometrix';
+import fs from 'fs';
+
+function dateString(): string {
+	const re1 = /[-:]/g;
+	const re2 = /\..*$/;
+	const rDateStr = new Date().toISOString().replace(re1, '').replace(re2, '').replace('T', '_');
+	return rDateStr;
+}
+
+function createDir(iDir: string): string {
+	let rlog = '';
+	if (!fs.existsSync(iDir)) {
+		fs.mkdirSync(iDir, { recursive: true });
+		rlog += `info203: mkdir ${iDir}\n`;
+	}
+	return rlog;
+}
+
+async function write_binFile(fName: string, fContent: Blob): Promise<string> {
+	let rlog = '';
+	const buffer = await fContent.arrayBuffer();
+	const arrBufView = new DataView(buffer);
+	fs.writeFileSync(fName, arrBufView);
+	rlog += `info304: bin-file ${fName} has been written\n`;
+	return rlog;
+}
+
+function write_textFile(fName: string, fContent: string): string {
+	let rlog = '';
+	fs.writeFileSync(fName, fContent);
+	rlog += `info405: text-file ${fName} has been written\n`;
+	return rlog;
+}
+
+function checkDirFName(iDir: string, fName: string): string {
+	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: string,
+	idparams: tParamVal,
+	oDir: string,
+	oFileName: string
+): string {
+	const re1 = /[-:]/g;
+	const re2 = /\..*$/;
+	const datestr = 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}\n`;
+	const file_content = createParamFile(datestr, idparams, 'Written by geom_cli');
+	rlog += createDir(oDir);
+	write_textFile(fName2, file_content);
+	return rlog;
+}
+
+function readParams(paramPath: string, printLog: boolean): tParamVal {
+	let rParamVal: tParamVal = {};
+	if (paramPath !== '') {
+		let rlog = `Read parameter file ${paramPath}\n`;
+		if (!fs.existsSync(paramPath)) {
+			throw `err533: file ${paramPath} doesn't exist!`;
+		}
+		const fContentStr = fs.readFileSync(paramPath, 'utf8');
+		const [obj] = parseParamFile(fContentStr);
+		//const [obj, tlog] = parseParamFile(fContentStr);
+		//rlog += tlog;
+		rlog += `file lastModif: ${obj.lastModif}\n`;
+		rlog += `file comment: ${obj.comment}\n`;
+		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: string,
+	fgeom: tGeomFunc,
+	simTime: number,
+	iParam: tParamVal,
+	iFormat: EFormat,
+	iFace = '',
+	iDir = '.',
+	iFname = ''
+): Promise<string> {
+	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;
+}
+
+export { geom_write, writeParams, readParams };

package/src/index.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { geom_cli } from './index';
+import type { tAllPageDef } from 'geometrix';
+
+import { heliostatDef, swingDef } from 'designix';
+
+const designList: tAllPageDef = {
+	'heliostat/heliostat': heliostatDef,
+	'heliostat/swing': swingDef
+};
+
+describe('geomcli index suit', () => {
+	it('geom_cli', async () => {
+		await expect(geom_cli(['node', 'dummy', 'list'], designList)).resolves.toBeUndefined();
+	});
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+// geomcli index.ts
+
+import { geom_write } from './geom_write';
+import { geom_cli } from './geom_cli';
+
+export { geom_write, geom_cli };

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "esnext",
+		"module": "esnext",
+		"outDir": "./build",
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"moduleResolution": "bundler",
+		"declaration": true,
+		"sourceMap": true,
+		"strict": true
+	},
+	"include": ["./src"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+	test: {
+		include: ['src/**/*.{test,spec}.{js,ts}']
+	}
+});