@meshioplusplus/wasm 16.25.0 → 16.29.0

package/index.d.ts

@@ -239,13 +239,42 @@ export interface MedInfo {
   fieldTimeValues: Record<string, number[]>;
 }
 
-/** MDPA's side channel: per-block entity names. Properties ride on `mesh.propertySets` instead (see {@link PropertySet}), not here. */
+/**
+ * MDPA's side channel: per-block entity names and every block the mesh cannot
+ * hold. Properties ride on `mesh.propertySets` instead (see {@link PropertySet}),
+ * not here. Point references (`geometries[].conn`, `meshBlocks[].nodes`) are
+ * 0-based point rows; entity and table ids are the file's own.
+ */
 export interface MdpaInfo {
   format: 'mdpa';
   /** One entry per cell block, mesh block order. */
   entityNames: Array<{ name: string; isCondition: boolean }>;
   /** Lenient-mode only: constructs this read could not represent, verbatim. */
   skippedConstructs: string[];
+  /** The non-numeric `ModelPartData` entries (`text` set); numeric ones are `fieldData`. */
+  modelPartData?: PropertyValue[];
+  /** Top-level `Begin Table` blocks: `key` holds the header arguments (`"1 TIME VALUE"`). */
+  tables?: PropertyValue[];
+  /** `Begin Geometries` runs: `conn` is flat row-major `(n, nodes per geometry)`. */
+  geometries?: Array<{ name: string; type: string; conn: Float64Array; ids: number[] }>;
+  /** `Begin Mesh <id>` blocks. */
+  meshBlocks?: Array<{
+    id: number;
+    data: PropertyValue[];
+    nodes: number[];
+    elementIds: number[];
+    conditionIds: number[];
+  }>;
+  /** Data and membership, by hierarchical part name; ids stay raw and are not remapped by operations. */
+  subModelParts?: Array<{
+    name: string;
+    data: PropertyValue[];
+    tables: number[];
+    geometryIds?: number[];
+    constraintIds?: number[];
+  }>;
+  /** Every other top-level block (`Constraints`, ...), kept verbatim. */
+  rawBlocks?: Array<{ header: string; body: string; end: string }>;
 }
 
 /**
@@ -271,6 +300,9 @@ export interface UnvInfo extends AnsysUnvInfoShape {
 export interface GmshInfo {
   format: 'gmsh';
   boundingEntities: number[][];
+  /** Entity tags are raw ids; nodePairs is flattened (N,2), 0-based point rows.
+   * Ordering/duplicates survive I/O; mesh operations do not remap these rows. */
+  periodic?: { entity: number[]; affine: number[]; nodePairs: BigInt64Array | number[] }[];
 }
 
 /** Exodus's side channel: info/QA records. Read-only -- there is no Info-bearing Exodus writer. */
@@ -362,11 +394,31 @@ export interface RegionSummary {
  * `WriteOptions` field on the C++ side (gzip level 4 is a fixed registry
  * default; `vtk42`/`vtk51` are separate format keys, not a `vtk` option).
  */
+/** glTF writer parameters. Components are 0-based; omitted selects magnitude. */
+export interface GltfWriteOptions {
+  colorBy?: string;
+  cmap?: "viridis" | "coolwarm" | "turbo";
+  component?: number;
+  vmin?: number;
+  vmax?: number;
+  splitAngle?: number;
+  upAxis?: "auto" | "x" | "y" | "z";
+  scale?: number;
+  container?: "auto" | "glb" | "gltf";
+  normalWeight?: "angle" | "area";
+  normals?: boolean;
+  fields?: boolean;
+  recenter?: boolean;
+  byRegion?: boolean;
+  unlit?: boolean;
+  nanColor?: string;
+}
+
 export interface MeshWriteOptions {
   /** ASCII vs binary. Errors for a format with only one variant. */
   encoding?: "ascii" | "binary";
-  /** Block-compression codec, for the VTK-XML formats (vtu/vtp) only. */
-  codec?: "none" | "zlib" | "lz4" | "zstd";
+  /** VTK block codec, or `lzf` for PCD binary_compressed (not ASCII). */
+  codec?: "none" | "zlib" | "lz4" | "zstd" | "lzf";
   /** `printf`-style float format for ASCII writers that take one (e.g. `".16e"`, the default). */
   floatFormat?: string;
 }
@@ -890,9 +942,21 @@ export type XdmfDataFormat = 'HDF' | 'XML' | 'Binary';
  * `'XML'` writes one self-contained file and needs no companion; `'Binary'`
  * writes the `.xdmf` plus one `<path minus extension><n>.bin` per array.
  */
+/** Fixed Exodus geometry, sets and attributes; step fields have a stable schema.
+ * Available in netCDF-enabled builds, including the shipped WASM artifacts. */
+export interface ExodusTimeSeriesWriter {
+  writePointsCells(mesh: Mesh): void;
+  writeData(time: number, mesh: Mesh): void;
+  flush(): void;
+  finalize(): void;
+  numSteps(): number;
+  finalized(): boolean;
+  close(): void;
+}
+
 export interface XdmfTimeSeriesWriter {
   /**
-   * Write the static grid -- the points and cell blocks every step shares.
+    * Write the static grid -- points, cell blocks and fixed regions shared by every step.
    * Only geometry and connectivity are used; any data on `mesh` is ignored,
    * because in a series data belongs to a step. Call exactly once, before the
    * first `writeData`.
@@ -1016,6 +1080,10 @@ export interface MeshioPlusPlusModule {
    * @throws {Error} on an unknown/unsupported format or a malformed file.
    */
   readMesh(path: string, format?: string): Mesh;
+  /** MED named meshes require an HDF5-enabled build. Profiles expand with NaN fill. */
+  medMeshNames(path: string): string[];
+  readMedNamed(path: string, name: string, options?: { timeStep?: number; lenient?: boolean }): Mesh;
+  writeMedMulti(path: string, meshes: Mesh[], names: string[], options?: { version?: string }): void;
 
   /**
    * Read only part of a file: geometry alone, or a named subset of data arrays.
@@ -1095,6 +1163,8 @@ export interface MeshioPlusPlusModule {
   writeMesh(
     path: string, mesh: Mesh, format?: string, options?: MeshWriteOptionsWithInfo
   ): string[];
+  /** Export a parameterized glTF surface and return every written MEMFS path. */
+  writeGltf(path: string, mesh: Mesh, options?: GltfWriteOptions): string[];
 
   /**
    * Read `inPath` and write it to `outPath` directly (no intermediate JS
@@ -1158,6 +1228,11 @@ export interface MeshioPlusPlusModule {
    * {@link convertSurfaceOps}' pre-existing camelCase op specs — the two
    * dispatch through the same core engine, differing only in spelling. The
    * returned report's counter keys are PascalCase too.
+   * Version 2 adds per-step `Inputs` for Merge/Interpolate/UndoGreen and
+   * terminal Split/Partition with `Output.Pattern` (`{key}`/`{part}`).
+   * Auxiliary inputs and generated outputs are MEMFS paths. Version 1 and
+   * label-only Partition remain unchanged; spatial v2 steps are not a
+   * transient sequence schema.
    *
    * Unlike {@link convertSurfaceOps} there is no surface-extraction tail:
    * what the pipeline produces is what is written.
@@ -2100,6 +2175,60 @@ export interface MeshioPlusPlusModule {
    */
   editRegions(mesh: Mesh, edits: RegionEdit | RegionEdit[]): Mesh;
 
+  /** Return conforming facets shared by Cell regions (or cell blocks when needed). */
+  regionAdjacency(mesh: Mesh, regions?: Array<string | RegionSelector>): Mesh;
+
+  /** Find conforming or proximity-matched facets; side entries are (cell, local facet). */
+  findInterface(
+    meshA: Mesh,
+    regionA: string | RegionSelector,
+    regionB: string | RegionSelector,
+    options?: {
+      meshB?: Mesh;
+      mode?: "conforming" | "proximity";
+      master?: "a" | "b";
+      gapTolerance?: number;
+      angleTolerance?: number;
+      overlapTolerance?: number;
+    },
+  ): {
+    mesh: Mesh;
+    report: {
+      numPairs: number;
+      area: number;
+      maxGap: number;
+      unmatchedA: number;
+      unmatchedB: number;
+      sideA: Array<[number, number]>;
+      sideB: Array<[number, number]>;
+    };
+  };
+
+  /** Project a Point region onto Cell-region facets. */
+  contactPairs(
+    slaveMesh: Mesh,
+    slavePoints: string | RegionSelector,
+    masterCells: string | RegionSelector,
+    options?: { masterMesh?: Mesh; tolerance?: number; requireComplete?: boolean },
+  ): {
+    slavePoint: Int32Array;
+    masterCell: Int32Array;
+    masterFacet: Int32Array;
+    masterSubfacet: Int32Array;
+    localCoordinates: Float64Array;
+    closestPoint: Float64Array;
+    gap: Float64Array;
+    normal: Float64Array;
+    unmatched: Int32Array;
+  };
+
+  /** Split a mesh along a Side region, optionally inserting cohesive cells. */
+  splitInterface(
+    mesh: Mesh,
+    side: string | RegionSelector,
+    options?: { addCohesive?: boolean },
+  ): { mesh: Mesh; report: { numDuplicatedPoints: number; numCohesiveCells: number } };
+
   /**
    * The master node each node of the `slave` region maps onto under the
    * row-major 4x4 affine `matrix` (16 numbers), within `atol`. `slave` is
@@ -2487,6 +2616,13 @@ export interface MeshioPlusPlusModule {
 
   /** Rename one array, preserving its values and dtype. */
   dataRename(mesh: Mesh, location: DataLocation, from: string, to: string): Mesh;
+  /** Convert region-backed sets to zero-based labels; overlaps use the later
+   * set and uncovered entities use -1. Removes converted regions. */
+  setsToData(mesh: Mesh, location: 'point' | 'cell', options?: {
+    dataName?: string | null; joinChar?: string; order?: string[];
+  }): Mesh;
+  /** Convert a scalar integer field to sets and remove that field. */
+  dataToSets(mesh: Mesh, location: 'point' | 'cell', key: string): Mesh;
 
   /** Average point_data onto the cells (mean over each cell's own nodes). */
   dataPointToCell(mesh: Mesh, names?: string[], suffix?: string): Mesh;
@@ -2578,6 +2714,8 @@ export interface MeshioPlusPlusModule {
       autoFlush?: boolean;
     },
   ): XdmfTimeSeriesWriter;
+  /** Requires netCDF; custom builds without it throw naming the dependency. */
+  createExodusTimeSeriesWriter(path: string): ExodusTimeSeriesWriter;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshioplusplus/wasm",
-  "version": "16.25.0",
+  "version": "16.29.0",
   "description": "meshio++ mesh I/O compiled to WebAssembly: read 76 and write 68 mesh formats (incl. MED, CGNS, Exodus) in the browser or Node.js",
   "type": "module",
   "main": "./src/index.mjs",

package/src/index.mjs

@@ -256,6 +256,10 @@ export class MeshioPlusPlusLoadError extends Error {
  *   featureEdges: (mesh: Mesh, featureAngle?: number, feature?: boolean, boundary?: boolean, nonManifold?: boolean, inconsistent?: boolean, region?: string) => {mesh: Mesh, numFeature: number, numBoundary: number, numNonManifold: number, numInconsistent: number},
  *   hausdorffDistance: (a: Mesh, b: Mesh, faceSamples?: number, regionA?: string, regionB?: string) => {distance: number, aToB: number, bToA: number, meanAToB: number, rmsAToB: number, meanBToA: number, rmsBToA: number, numSamplesA: number, numSamplesB: number, worstPointA: Float64Array, worstPointB: Float64Array},
  *   editRegions: (mesh: Mesh, edits: Array<{op: string, inputs: Array<string | {name: string, kind?: string, dim?: number, tag?: number}>, output?: string, dim?: number, tag?: number, keepInputs?: boolean}>) => Mesh,
+ *   regionAdjacency: (mesh: Mesh, regions?: Array<string | {name: string, kind?: string, dim?: number, tag?: number}>) => Mesh,
+ *   findInterface: (meshA: Mesh, regionA: string | object, regionB: string | object, options?: {meshB?: Mesh, mode?: 'conforming'|'proximity', master?: 'a'|'b', gapTolerance?: number, angleTolerance?: number, overlapTolerance?: number}) => {mesh: Mesh, report: object},
+ *   contactPairs: (slaveMesh: Mesh, slavePoints: string | object, masterCells: string | object, options?: {masterMesh?: Mesh, tolerance?: number, requireComplete?: boolean}) => object,
+ *   splitInterface: (mesh: Mesh, side: string | object, options?: {addCohesive?: boolean}) => {mesh: Mesh, report: object},
  *   matchPeriodicNodes: (mesh: Mesh, slave: string | {name: string, kind?: string, dim?: number, tag?: number}, master: string | {name: string, kind?: string, dim?: number, tag?: number}, matrix: ArrayLike<number>, atol?: number, requireComplete?: boolean) => {slave: Int32Array, master: Int32Array, unmatched: Int32Array, numFixed: number, maxResidual: number},
  *   repair: (mesh: Mesh, fixOrientation?: boolean, orientOutward?: boolean, fillHoles?: boolean, splitNonManifold?: boolean, maxHoleEdges?: number, weldTolerance?: number, recordProvenance?: boolean) => {mesh: Mesh, qualityBefore: object, qualityAfter: object, numFlipped: number, numComponents: number, largestComponent: number, numOrientedOutward: number, numUnorientable: number, numVerticesSplit: number, numHolesDetected: number, numHolesFilled: number, numHolesSkipped: number, numFacesAdded: number, numPointsAdded: number, pointsWelded: number},
  *   shrinkwrap: (mesh: Mesh, target: Mesh, offset?: number, maxDistance?: number, weights?: string, targetRegion?: string, normalWeight?: string, recordDistance?: boolean, recordClosestCell?: boolean) => {mesh: Mesh, quality: object, numProjected: number, numMissed: number, numSkipped: number, maxDisplacement: number},
@@ -281,6 +285,8 @@ export class MeshioPlusPlusLoadError extends Error {
  *   dataDrop: (mesh: Mesh, location: string, names?: string[], ignoreMissing?: boolean) => Mesh,
  *   dataKeep: (mesh: Mesh, location: string, names?: string[], ignoreMissing?: boolean) => Mesh,
  *   dataRename: (mesh: Mesh, location: string, from: string, to: string) => Mesh,
+ *   setsToData: (mesh: Mesh, location: string, options?: object) => Mesh,
+ *   dataToSets: (mesh: Mesh, location: string, key: string) => Mesh,
  *   dataPointToCell: (mesh: Mesh, names?: string[], suffix?: string) => Mesh,
  *   dataCellToPoint: (mesh: Mesh, names?: string[], weight?: string, suffix?: string) => Mesh,
  *   dataCalc: (mesh: Mesh, expression: string, location: string, outputName: string, overwrite?: boolean) => Mesh,
@@ -289,6 +295,11 @@ export class MeshioPlusPlusLoadError extends Error {
  *   dataInfo: (mesh: Mesh) => object[],
  *   dataIntegrate: (mesh: Mesh, arrays?: string[]) => object[],
  *   createXdmfTimeSeriesWriter: (path: string, options?: {dataFormat?: string, gzipLevel?: number, mode?: 'truncate'|'append', autoFlush?: boolean}) => XdmfTimeSeriesWriter,
+ *   createExodusTimeSeriesWriter: (path: string) => ExodusTimeSeriesWriter,
+ *   medMeshNames: (path: string) => string[],
+ *   readMedNamed: (path: string, name: string, options?: object) => Mesh,
+ *   writeMedMulti: (path: string, meshes: Mesh[], names: string[], options?: object) => void,
+ *   writeGltf: (path: string, mesh: Mesh, options?: object) => string[],
  *   openSequence: (source: string|string[], options?: object) => SequenceReader,
  * }>}
  * @throws {MeshioPlusPlusLoadError} if the WASM module fails to instantiate.
@@ -361,6 +372,11 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
     return {
         FS: Module.FS,
         readMesh: (path, format = '') => Module.readMesh(path, format),
+        medMeshNames: (path) => Module.medMeshNames(path),
+        readMedNamed: (path, name, { timeStep = 0, lenient = false } = {}) =>
+            Module.readMedNamed(path, name, timeStep, lenient),
+        writeMedMulti: (path, meshes, names, { version = '4.1.0' } = {}) =>
+            Module.writeMedMulti(path, meshes, names, version),
         // Selective reads (see doc/selective_read.md). `arrays: null` reads
         // every data array, `arrays: []` reads none -- the distinction is
         // deliberate. Formats without a native selective path are read whole
@@ -415,6 +431,7 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         // an OpenFOAM `polyMesh` directory's files, ...).
         writeMesh: (path, mesh, format = '', options = undefined) =>
             Module.writeMesh(path, mesh, format, options),
+        writeGltf: (path, mesh, options = undefined) => Module.writeGltf(path, mesh, options),
         // `options` adds `encoding`/`codec`/`floatFormat` to `inFormat`/
         // `outFormat` (see `writeMesh`). Returns the written paths, as
         // `writeMesh` does.
@@ -805,6 +822,12 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
             Module.hausdorffDistance(a, b, faceSamples, regionA, regionB),
         editRegions: (mesh, edits) =>
             Module.editRegions(mesh, Array.isArray(edits) ? edits : [edits]),
+        regionAdjacency: (mesh, regions = []) => Module.regionAdjacency(mesh, regions),
+        findInterface: (meshA, regionA, regionB, options = {}) =>
+            Module.findInterface(meshA, regionA, regionB, options),
+        contactPairs: (slaveMesh, slavePoints, masterCells, options = {}) =>
+            Module.contactPairs(slaveMesh, slavePoints, masterCells, options),
+        splitInterface: (mesh, side, options = {}) => Module.splitInterface(mesh, side, options),
         matchPeriodicNodes: (mesh, slave, master, matrix, atol = 1e-8, requireComplete = true) =>
             Module.matchPeriodicNodes(mesh, slave, master, Array.from(matrix), atol,
                 requireComplete),
@@ -992,6 +1015,9 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         dataKeep: (mesh, location, names = [], ignoreMissing = false) =>
             Module.dataKeep(mesh, location, names, ignoreMissing),
         dataRename: (mesh, location, from, to) => Module.dataRename(mesh, location, from, to),
+        setsToData: (mesh, location, {dataName = null, joinChar = '-', order = []} = {}) =>
+            Module.setsToData(mesh, location, dataName, joinChar, order),
+        dataToSets: (mesh, location, key) => Module.dataToSets(mesh, location, key),
         dataPointToCell: (mesh, names = [], suffix = '') =>
             Module.dataPointToCell(mesh, names, suffix),
         dataCellToPoint: (mesh, names = [], weight = 'uniform', suffix = '') =>
@@ -1035,6 +1061,24 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         // dataFormat 'HDF' the series is TWO files in the virtual FS: `<path>`
         // and its sibling `<path minus extension>.h5`. Copy BOTH out of
         // Module.FS. `mode: 'append'` continues a series already at `path`.
+        createExodusTimeSeriesWriter: (path) => {
+            const handle = Module.exodusSeriesCreate(path);
+            let open = true;
+            const action = (name, time = 0, mesh = null) => Module.exodusSeriesAction(handle, name, time, mesh);
+            return {
+                writePointsCells: (mesh) => action('grid', 0, mesh),
+                writeData: (time, mesh) => action('data', time, mesh),
+                flush: () => action('flush'),
+                finalize: () => action('finalize'),
+                numSteps: () => action('steps'),
+                finalized: () => action('finalized'),
+                close: () => {
+                    if (!open) return;
+                    open = false;
+                    try { action('finalize'); } finally { action('free'); }
+                },
+            };
+        },
         createXdmfTimeSeriesWriter: (
             path,
             { dataFormat = 'HDF', gzipLevel = -1, mode = 'truncate', autoFlush = false } = {},