config-disassembler 1.0.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Matthew Carvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,358 @@
+# config-disassembler-node
+
+[![NPM](https://img.shields.io/npm/v/config-disassembler.svg?label=config-disassembler)](https://www.npmjs.com/package/config-disassembler)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://raw.githubusercontent.com/mcarvin8/config-disassembler-node/main/LICENSE.md)
+[![Downloads/week](https://img.shields.io/npm/dw/config-disassembler.svg)](https://npmjs.org/package/config-disassembler)
+
+Node.js bindings for the Rust [`config-disassembler`](https://crates.io/crates/config-disassembler) crate.
+
+Disassemble configuration files (XML, JSON, JSON5, JSONC, YAML, TOON, TOML, INI) into smaller, version-control–friendly pieces — and reassemble them on demand.
+
+> **Native Rust:** All work is done in [`config-disassembler`](https://crates.io/crates/config-disassembler); this package provides Node.js bindings via [Neon](https://neon-bindings.com).
+
+---
+
+## Table of contents
+
+- [Quick start](#quick-start)
+- [Install](#install)
+- [Supported formats](#supported-formats)
+- [XML API](#xml-api)
+  - [Disassembling XML](#disassembling-xml)
+  - [Disassembly strategies](#disassembly-strategies)
+  - [Split tags (splitTags)](#split-tags-splittags)
+  - [Multi-level disassembly](#multi-level-disassembly)
+  - [Reassembling XML](#reassembling-xml)
+- [Value-format API (JSON / JSON5 / JSONC / YAML / TOON / TOML / INI)](#value-format-api)
+  - [Disassembling config files](#disassembling-config-files)
+  - [Reassembling config files](#reassembling-config-files)
+  - [TOML and INI isolation](#toml-and-ini-isolation)
+- [Ignore file](#ignore-file)
+- [Logging](#logging)
+- [Implementation](#implementation)
+- [Use case](#use-case)
+- [License](#license)
+
+---
+
+## Quick start
+
+```typescript
+import {
+  DisassembleXMLFileHandler,
+  ReassembleXMLFileHandler,
+  DisassembleConfigFileHandler,
+  ReassembleConfigFileHandler,
+} from "config-disassembler";
+
+// XML: disassemble one XML -> many small files
+const disassembleXml = new DisassembleXMLFileHandler();
+disassembleXml.disassemble({
+  filePath: "path/to/YourFile.permissionset-meta.xml",
+  uniqueIdElements:
+    "application,apexClass,name,flow,object,recordType,tab,field",
+  format: "json",
+  strategy: "unique-id",
+});
+
+const reassembleXml = new ReassembleXMLFileHandler();
+reassembleXml.reassemble({
+  filePath: "path/to/YourFile",
+  fileExtension: "permissionset-meta.xml",
+});
+
+// JSON / YAML / TOML / INI / etc.
+const disassembleCfg = new DisassembleConfigFileHandler();
+const outDir = disassembleCfg.disassemble({
+  input: "config.json",
+  outputFormat: "yaml",
+  uniqueId: "id",
+});
+
+const reassembleCfg = new ReassembleConfigFileHandler();
+reassembleCfg.reassemble({
+  inputDir: outDir,
+  output: "config.rebuilt.json",
+  outputFormat: "json",
+});
+```
+
+---
+
+## Install
+
+```bash
+npm install config-disassembler
+```
+
+---
+
+## Supported formats
+
+| Format | Disassemble | Reassemble | Cross-format conversions |
+| ------ | ----------- | ---------- | ------------------------- |
+| XML    | yes         | yes        | XML ↔ XML / JSON / JSON5 / YAML |
+| JSON   | yes         | yes        | within JSON / JSON5 / JSONC / YAML / TOON |
+| JSON5  | yes         | yes        | within JSON / JSON5 / JSONC / YAML / TOON |
+| JSONC  | yes         | yes        | within JSON / JSON5 / JSONC / YAML / TOON (comments preserved on JSONC <-> JSONC) |
+| YAML   | yes         | yes        | within JSON / JSON5 / JSONC / YAML / TOON |
+| TOON   | yes         | yes        | within JSON / JSON5 / JSONC / YAML / TOON |
+| TOML   | yes         | yes        | TOML <-> TOML only |
+| INI    | yes         | yes        | INI <-> INI only |
+
+See [TOML and INI isolation](#toml-and-ini-isolation) for the rationale on the same-format-only restriction.
+
+---
+
+## XML API
+
+Mirrors the standalone [`xml-disassembler`](https://github.com/mcarvin8/xml-disassembler-rust) crate (now hosted as the `xml` subcommand of `config-disassembler`). The on-disk layout, defaults, and option semantics are identical.
+
+### Disassembling XML
+
+```typescript
+import { DisassembleXMLFileHandler } from "config-disassembler";
+
+const handler = new DisassembleXMLFileHandler();
+handler.disassemble({
+  filePath: "test/baselines/general",
+  uniqueIdElements:
+    "application,apexClass,name,externalDataSource,flow,object,apexPage,recordType,tab,field",
+  prePurge: true,
+  postPurge: true,
+  ignorePath: ".cdignore",
+  format: "json",
+  strategy: "unique-id",
+});
+```
+
+| Option             | Description                                                                                                                           |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `filePath`         | Path to the XML file or directory to disassemble.                                                                                     |
+| `uniqueIdElements` | Comma-separated element names used to derive filenames for nested elements.                                                           |
+| `multiLevel`       | Optional. Multi-level spec: `file_pattern:root_to_strip:unique_id_elements`. See [Multi-level disassembly](#multi-level-disassembly). |
+| `splitTags`        | Optional. With `strategy: "grouped-by-tag"`: split or group nested tags. See [Split tags](#split-tags-splittags).                      |
+| `prePurge`         | Remove existing disassembly output before running (default: `false`).                                                                 |
+| `postPurge`        | Remove the source XML after disassembly (default: `false`).                                                                           |
+| `ignorePath`       | Path to the ignore file (default: `.cdignore`).                                                                                       |
+| `format`           | Output format: `xml`, `json`, `json5`, `yaml`.                                                                                        |
+| `strategy`         | `unique-id` or `grouped-by-tag`.                                                                                                      |
+
+### Disassembly strategies
+
+#### `unique-id` (default)
+
+Each nested element is written to its own file, named by a unique identifier (or an 8-character SHA-256 hash if no UID is available). Leaf content stays in a file named after the original XML.
+
+Best for fine-grained diffs and version control.
+
+#### `grouped-by-tag`
+
+All nested elements with the same tag go into one file per tag. Leaf content stays in the base file named after the original XML.
+
+Best for fewer files and quick inspection.
+
+```typescript
+handler.disassemble({
+  filePath: "my.xml",
+  strategy: "grouped-by-tag",
+  format: "yaml",
+});
+```
+
+### Split tags (`splitTags`)
+
+With `strategy: "grouped-by-tag"`, you can optionally split or group specific nested tags into subdirectories instead of a single file per tag. Useful for permission sets and similar metadata: e.g. one file per `objectPermissions` under `objectPermissions/`, and `fieldPermissions` grouped by object under `fieldPermissions/`.
+
+**Spec:** Comma-separated rules. Each rule is `tag:mode:field` or `tag:path:mode:field` (path defaults to tag). `mode` is `split` (one file per array item, filename from `field`) or `group` (group array items by `field`, one file per group).
+
+```typescript
+handler.disassemble({
+  filePath: "fixtures/split-tags/HR_Admin.permissionset-meta.xml",
+  strategy: "grouped-by-tag",
+  splitTags: "objectPermissions:split:object,fieldPermissions:group:field",
+  format: "xml",
+});
+```
+
+### Multi-level disassembly
+
+For XML with nested repeatable blocks (e.g. `programProcesses` inside `LoyaltyProgramSetup`), you can disassemble in one call and reassemble in one call. Pass a **multi-level spec** so the tool further splits matching files and later merges them in the right order.
+
+**Spec format:** `file_pattern:root_to_strip:unique_id_elements`
+
+```typescript
+import {
+  DisassembleXMLFileHandler,
+  ReassembleXMLFileHandler,
+} from "config-disassembler";
+
+const disassemble = new DisassembleXMLFileHandler();
+disassemble.disassemble({
+  filePath: "Cloud_Kicks_Inner_Circle.loyaltyProgramSetup-meta.xml",
+  uniqueIdElements: "fullName,name,processName",
+  multiLevel: "programProcesses:programProcesses:parameterName,ruleName",
+  postPurge: true,
+});
+
+const reassemble = new ReassembleXMLFileHandler();
+reassemble.reassemble({
+  filePath: "Cloud_Kicks_Inner_Circle",
+  fileExtension: "loyaltyProgramSetup-meta.xml",
+  postPurge: true,
+});
+```
+
+A `.multi_level.json` config is written in the disassembly root so reassembly knows how to merge inner levels first, then the top level. No extra options are needed for reassembly.
+
+**Caveat:** Multi-level reassembly removes disassembled directories after reassembling each level, even when you do not pass `postPurge`. This is required so the next level can merge the reassembled XML files.
+
+### Reassembling XML
+
+```typescript
+import { ReassembleXMLFileHandler } from "config-disassembler";
+
+const handler = new ReassembleXMLFileHandler();
+handler.reassemble({
+  filePath: "test/baselines/general/HR_Admin",
+  fileExtension: "permissionset-meta.xml",
+  postPurge: true,
+});
+```
+
+| Option          | Description                                                                       |
+| --------------- | --------------------------------------------------------------------------------- |
+| `filePath`      | Directory that contains the disassembled files (e.g. `HR_Admin/`).                |
+| `fileExtension` | Suffix for the rebuilt XML file (e.g. `permissionset-meta.xml`). Default: `.xml`. |
+| `postPurge`     | Remove disassembled files after a successful reassembly (default: `false`).       |
+
+---
+
+## Value-format API
+
+Use these classes for JSON, JSON5, JSONC, YAML, TOON, TOML, and INI files. Both methods are synchronous and return the relevant output path.
+
+### Disassembling config files
+
+```typescript
+import { DisassembleConfigFileHandler } from "config-disassembler";
+
+const handler = new DisassembleConfigFileHandler();
+
+// File input: writes split files into ./config/ next to config.json
+const outDir = handler.disassemble({
+  input: "config.json",
+});
+
+// Cross-format: split JSON into per-key YAML files
+handler.disassemble({
+  input: "config.json",
+  outputFormat: "yaml",
+  outputDir: "config-split",
+});
+
+// Array root: name files by a field on each element
+handler.disassemble({
+  input: "users.json",
+  uniqueId: "id",
+});
+
+// Directory input: walks the directory and disassembles every matching
+// file in place, using `.cdignore` (or `ignorePath`) to filter the walk.
+handler.disassemble({
+  input: "envs/",
+  inputFormat: "yaml",
+});
+```
+
+| Option         | Description                                                                                                                                                  |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `input`        | Path to a file or directory to disassemble.                                                                                                                  |
+| `inputFormat`  | Override input format. Defaults to detecting from the file extension (or each file's extension when `input` is a directory).                                  |
+| `outputFormat` | Format used for the split files. Defaults to `inputFormat`. Restricted to the input's compatible family.                                                     |
+| `outputDir`    | Directory to write split files to (single-file input only). Defaults to `<stem>` next to the input. Rejected for directory inputs.                           |
+| `uniqueId`    | For array roots, name files by this field on each element. Falls back to a zero-padded index when missing.                                                    |
+| `prePurge`     | Remove the output directory before writing (default: `false`).                                                                                               |
+| `postPurge`    | Delete the input file (or input directory, when empty after disassembly) after a successful run (default: `false`).                                          |
+| `ignorePath`   | `.gitignore`-style ignore file for directory walks. Defaults to `.cdignore` in the input directory.                                                          |
+
+The handler returns the path of the directory containing the split files (single-file input) or the input directory itself (directory input).
+
+A `.config-disassembler.json` sidecar is written into the output directory recording the original key order, root type, source format, and the format the split files were written in. Reassembly uses this metadata to rebuild the original document deterministically.
+
+### Reassembling config files
+
+```typescript
+import { ReassembleConfigFileHandler } from "config-disassembler";
+
+const handler = new ReassembleConfigFileHandler();
+
+// Default: rebuild using the original source format from the sidecar
+handler.reassemble({
+  inputDir: "config",
+});
+
+// Cross-format: rebuild a YAML-split tree as JSON
+handler.reassemble({
+  inputDir: "config",
+  output: "config.rebuilt.json",
+  outputFormat: "json",
+});
+```
+
+| Option         | Description                                                                                                            |
+| -------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `inputDir`     | Directory containing the split files and `.config-disassembler.json` sidecar.                                          |
+| `output`       | Output file path. Defaults to the original source filename recorded in the metadata, or `<dirname>.<ext>` next to it. |
+| `outputFormat` | Format to write the rebuilt file in. Defaults to the source format recorded in the metadata.                           |
+| `postPurge`    | Remove the disassembled directory after a successful reassembly (default: `false`).                                    |
+
+### TOML and INI isolation
+
+TOML and INI can only be disassembled and reassembled within the same format. TOML cannot represent `null`, forbids array roots, and forces bare keys to precede tables (which would reorder values on round-trip through other formats). INI is even narrower: section values are strings (or valueless keys) and arrays / nested objects cannot be represented without inventing a custom encoding.
+
+Trying to mix formats with TOML or INI throws a clear error:
+
+```
+TOML can only be converted to and from TOML; got input=json, output=toml
+INI can only be converted to and from INI; got input=json, output=ini
+```
+
+To keep every split file valid for table-style formats, TOML and INI wrap each per-key split file under its parent key (e.g. `dependencies.toml` contains `[dependencies]` headers, `settings.ini` contains `[settings]`). Reassembly unwraps them automatically using the metadata sidecar.
+
+---
+
+## Ignore file
+
+Exclude files or directories from disassembly using an ignore file (default: `.cdignore` in the input directory). Syntax is the same as [`.gitignore`](https://git-scm.com/docs/gitignore).
+
+```
+**/secret.json
+**/generated/
+```
+
+For backward compatibility, the XML API still falls back to `.xmldisassemblerignore` if `.cdignore` is missing — rename the file or pass `ignorePath` explicitly to silence the deprecation warning.
+
+---
+
+## Logging
+
+The Rust crate uses [env_logger](https://docs.rs/env_logger). Set `RUST_LOG` to control verbosity (e.g. `RUST_LOG=debug`).
+
+---
+
+## Implementation
+
+The core logic is implemented in Rust ([config-disassembler](https://crates.io/crates/config-disassembler)) and exposed to Node.js via [Neon](https://neon-bindings.com). Building from source requires Rust and Node.js.
+
+---
+
+## Use case
+
+For a Salesforce CLI integration example using the XML API, see [sf-decomposer](https://github.com/mcarvin8/sf-decomposer).
+
+---
+
+## License
+
+[MIT](LICENSE.md)

package/dist/index.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var path = require('path');
+
+function resolveNativeDir(baseDir, platform, arch) {
+    const isDist = path.basename(baseDir) === "dist";
+    return isDist
+        ? path.join(baseDir, "native", `${platform}-${arch}`)
+        : path.join(baseDir, "..", "dist", "native", `${platform}-${arch}`);
+}
+
+const nativeDir = resolveNativeDir(__dirname, process.platform, process.arch);
+const nativeAddon = require(path.join(nativeDir, "index.node"));
+class DisassembleXMLFileHandler {
+    disassemble(opts) {
+        nativeAddon.disassemble(opts);
+    }
+}
+class ReassembleXMLFileHandler {
+    reassemble(opts) {
+        nativeAddon.reassemble(opts);
+    }
+}
+class DisassembleConfigFileHandler {
+    disassemble(opts) {
+        return nativeAddon.disassembleConfig(opts);
+    }
+}
+class ReassembleConfigFileHandler {
+    reassemble(opts) {
+        return nativeAddon.reassembleConfig(opts);
+    }
+}
+
+exports.DisassembleConfigFileHandler = DisassembleConfigFileHandler;
+exports.DisassembleXMLFileHandler = DisassembleXMLFileHandler;
+exports.ReassembleConfigFileHandler = ReassembleConfigFileHandler;
+exports.ReassembleXMLFileHandler = ReassembleXMLFileHandler;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/native-dir.ts","../src/index.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;SAUgB,gBAAgB,CAC9B,OAAe,EACf,QAAgB,EAChB,IAAY,EAAA;IAEZ,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,MAAM;AAChD,IAAA,OAAO;AACL,UAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAA,EAAG,QAAQ,CAAA,CAAA,EAAI,IAAI,EAAE;AACpD,UAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAA,EAAG,QAAQ,IAAI,IAAI,CAAA,CAAE,CAAC;AACvE;;AChBA,MAAM,SAAS,GAAG,gBAAgB,CAChC,SAAS,EACT,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,IAAI,CACb;AACD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;MAsBlD,yBAAyB,CAAA;AACpC,IAAA,WAAW,CAAC,IAUX,EAAA;AACC,QAAA,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC;IAC/B;AACD;MAOY,wBAAwB,CAAA;AACnC,IAAA,UAAU,CAAC,IAIV,EAAA;AACC,QAAA,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC;IAC9B;AACD;MAaY,4BAA4B,CAAA;AACvC,IAAA,WAAW,CAAC,IASX,EAAA;AACC,QAAA,OAAO,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC;IAC5C;AACD;MAQY,2BAA2B,CAAA;AACtC,IAAA,UAAU,CAAC,IAKV,EAAA;AACC,QAAA,OAAO,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC;IAC3C;AACD;;;;;;;"}

package/dist/index.min.cjs

@@ -0,0 +1,2 @@
+"use strict";var e=require("path");const s=(a=__dirname,r=process.platform,i=process.arch,"dist"===e.basename(a)?e.join(a,"native",`${r}-${i}`):e.join(a,"..","dist","native",`${r}-${i}`));var a,r,i;const l=require(e.join(s,"index.node"));exports.DisassembleConfigFileHandler=class{disassemble(e){return l.disassembleConfig(e)}},exports.DisassembleXMLFileHandler=class{disassemble(e){l.disassemble(e)}},exports.ReassembleConfigFileHandler=class{reassemble(e){return l.reassembleConfig(e)}},exports.ReassembleXMLFileHandler=class{reassemble(e){l.reassemble(e)}};
+//# sourceMappingURL=index.min.cjs.map

package/dist/index.min.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.min.cjs","sources":["../src/index.ts","../src/native-dir.ts"],"sourcesContent":[null,null],"names":["nativeDir","baseDir","__dirname","platform","process","arch","path","basename","join","nativeAddon","require","disassemble","opts","disassembleConfig","reassemble","reassembleConfig"],"mappings":"mCAGA,MAAMA,GCQJC,EDPAC,UCQAC,EDPAC,QAAQD,SCQRE,EDPAD,QAAQC,KCSkC,SAA3BC,EAAKC,SAASN,GAEzBK,EAAKE,KAAKP,EAAS,SAAU,GAAGE,KAAYE,KAC5CC,EAAKE,KAAKP,EAAS,KAAM,OAAQ,SAAU,GAAGE,KAAYE,UAP9DJ,EACAE,EACAE,EDLF,MAAMI,EAAcC,QAAQJ,EAAKE,KAAKR,EAAW,0DAiE/C,WAAAW,CAAYC,GAUV,OAAOH,EAAYI,kBAAkBD,EACvC,2CArDA,WAAAD,CAAYC,GAWVH,EAAYE,YAAYC,EAC1B,6CAmDA,UAAAE,CAAWF,GAMT,OAAOH,EAAYM,iBAAiBH,EACtC,0CAjDA,UAAAE,CAAWF,GAKTH,EAAYK,WAAWF,EACzB"}

package/dist/index.min.mjs

@@ -0,0 +1,2 @@
+import s from"path";import{createRequire as e}from"module";import{fileURLToPath as r}from"url";const m=s.dirname(r(import.meta.url)),a=s.join(m,"native",process.platform+"-"+process.arch),o=e(import.meta.url)(s.join(a,"index.node"));class l{disassemble(s){o.disassemble(s)}}class i{reassemble(s){o.reassemble(s)}}class t{disassemble(s){return o.disassembleConfig(s)}}class n{reassemble(s){return o.reassembleConfig(s)}}export{t as DisassembleConfigFileHandler,l as DisassembleXMLFileHandler,n as ReassembleConfigFileHandler,i as ReassembleXMLFileHandler};
+//# sourceMappingURL=index.min.mjs.map

package/dist/index.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.min.mjs","sources":["../src/native-dir.ts","../src/index.ts"],"sourcesContent":[null,null],"names":["fileURLToPath","__dirname","path","dirname","url","nativeDir","join","platform","process","arch","nativeAddon","createRequire","DisassembleXMLFileHandler","disassemble","opts","ReassembleXMLFileHandler","reassemble","DisassembleConfigFileHandler","disassembleConfig","ReassembleConfigFileHandler","reassembleConfig"],"mappings":"mFAUgBA,MACd,MAKA,MAAAC,EAAOC,EAAAC,QAAAH,cAAAI,MACLC,EAAOH,EAAKI,OAAmB,iBAAeC,SAAM,IAAAC,QAAAC,MACpDC,EAAYC,kBAAAA,CAA+BT,EAAKI,KAAAD,EAAgB,eACpE,MAAAO,iBChBMF,EAAYG,YAAAC,EAKlB,EAuBE,MAAAC,EAWE,UAAAC,CAAAF,GACFJ,EAAAM,WAAAF,EACD,EAQC,MAAAG,EAKE,WAAAJ,CAAAC,GACF,OAAAJ,EAAAQ,kBAAAJ,EACD,EAcC,MAAAK,EAUE,UAAAH,CAAOF,GACT,OAAAJ,EAAAU,iBAAAN,EACD,2CAesBF,+BAAsBO,iCAAAJ"}

package/dist/index.min.umd.js

@@ -0,0 +1,2 @@
+!function(e,s){"object"==typeof exports&&"undefined"!=typeof module?s(exports,require("path")):"function"==typeof define&&define.amd?define(["exports","path"],s):s((e="undefined"!=typeof globalThis?globalThis:e||self).jsTemplate={},e.path)}(this,function(e,s){"use strict";const i=(a=__dirname,n=process.platform,l=process.arch,"dist"===s.basename(a)?s.join(a,"native",`${n}-${l}`):s.join(a,"..","dist","native",`${n}-${l}`));var a,n,l;const o=require(s.join(i,"index.node"));e.DisassembleConfigFileHandler=class{disassemble(e){return o.disassembleConfig(e)}},e.DisassembleXMLFileHandler=class{disassemble(e){o.disassemble(e)}},e.ReassembleConfigFileHandler=class{reassemble(e){return o.reassembleConfig(e)}},e.ReassembleXMLFileHandler=class{reassemble(e){o.reassemble(e)}}});
+//# sourceMappingURL=index.min.umd.js.map

package/dist/index.min.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.min.umd.js","sources":["../src/index.ts","../src/native-dir.ts"],"sourcesContent":[null,null],"names":["nativeDir","baseDir","__dirname","platform","process","arch","path","basename","join","nativeAddon","require","disassemble","opts","disassembleConfig","reassemble","reassembleConfig"],"mappings":"iRAGA,MAAMA,GCQJC,EDPAC,UCQAC,EDPAC,QAAQD,SCQRE,EDPAD,QAAQC,KCSkC,SAA3BC,EAAKC,SAASN,GAEzBK,EAAKE,KAAKP,EAAS,SAAU,GAAGE,KAAYE,KAC5CC,EAAKE,KAAKP,EAAS,KAAM,OAAQ,SAAU,GAAGE,KAAYE,UAP9DJ,EACAE,EACAE,EDLF,MAAMI,EAAcC,QAAQJ,EAAKE,KAAKR,EAAW,oDAiE/C,WAAAW,CAAYC,GAUV,OAAOH,EAAYI,kBAAkBD,EACvC,qCArDA,WAAAD,CAAYC,GAWVH,EAAYE,YAAYC,EAC1B,uCAmDA,UAAAE,CAAWF,GAMT,OAAOH,EAAYM,iBAAiBH,EACtC,oCAjDA,UAAAE,CAAWF,GAKTH,EAAYK,WAAWF,EACzB"}

package/dist/index.mjs

@@ -0,0 +1,30 @@
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const nativeDir = path.join(__dirname, 'native', process.platform + '-' + process.arch);
+const nativeAddon = createRequire(import.meta.url)(path.join(nativeDir, 'index.node'));
+class DisassembleXMLFileHandler {
+    disassemble(opts) {
+        nativeAddon.disassemble(opts);
+    }
+}
+class ReassembleXMLFileHandler {
+    reassemble(opts) {
+        nativeAddon.reassemble(opts);
+    }
+}
+class DisassembleConfigFileHandler {
+    disassemble(opts) {
+        return nativeAddon.disassembleConfig(opts);
+    }
+}
+class ReassembleConfigFileHandler {
+    reassemble(opts) {
+        return nativeAddon.reassembleConfig(opts);
+    }
+}
+
+export { DisassembleConfigFileHandler, DisassembleXMLFileHandler, ReassembleConfigFileHandler, ReassembleXMLFileHandler };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/native-dir.ts","../src/index.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;SAUgB,gBAAgB,CAC9B,OAAe,EACf,QAAgB,EAChB,IAAY,EAAA;IAEZ,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,MAAM;AAChD,IAAA,OAAO;AACL,UAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAA,EAAG,QAAQ,CAAA,CAAA,EAAI,IAAI,EAAE;AACpD,UAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAA,EAAG,QAAQ,IAAI,IAAI,CAAA,CAAE,CAAC;AACvE;;AChBA,MAAM,SAAS,GAAG,gBAAgB,CAChC,SAAS,EACT,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,IAAI,CACb;AACD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;MAsBlD,yBAAyB,CAAA;AACpC,IAAA,WAAW,CAAC,IAUX,EAAA;AACC,QAAA,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC;IAC/B;AACD;MAOY,wBAAwB,CAAA;AACnC,IAAA,UAAU,CAAC,IAIV,EAAA;AACC,QAAA,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC;IAC9B;AACD;MAaY,4BAA4B,CAAA;AACvC,IAAA,WAAW,CAAC,IASX,EAAA;AACC,QAAA,OAAO,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC;IAC5C;AACD;MAQY,2BAA2B,CAAA;AACtC,IAAA,UAAU,CAAC,IAKV,EAAA;AACC,QAAA,OAAO,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC;IAC3C;AACD;;;;"}

package/dist/index.umd.js

@@ -0,0 +1,43 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('path')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'path'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jsTemplate = {}, global.path));
+})(this, (function (exports, path) { 'use strict';
+
+    function resolveNativeDir(baseDir, platform, arch) {
+        const isDist = path.basename(baseDir) === "dist";
+        return isDist
+            ? path.join(baseDir, "native", `${platform}-${arch}`)
+            : path.join(baseDir, "..", "dist", "native", `${platform}-${arch}`);
+    }
+
+    const nativeDir = resolveNativeDir(__dirname, process.platform, process.arch);
+    const nativeAddon = require(path.join(nativeDir, "index.node"));
+    class DisassembleXMLFileHandler {
+        disassemble(opts) {
+            nativeAddon.disassemble(opts);
+        }
+    }
+    class ReassembleXMLFileHandler {
+        reassemble(opts) {
+            nativeAddon.reassemble(opts);
+        }
+    }
+    class DisassembleConfigFileHandler {
+        disassemble(opts) {
+            return nativeAddon.disassembleConfig(opts);
+        }
+    }
+    class ReassembleConfigFileHandler {
+        reassemble(opts) {
+            return nativeAddon.reassembleConfig(opts);
+        }
+    }
+
+    exports.DisassembleConfigFileHandler = DisassembleConfigFileHandler;
+    exports.DisassembleXMLFileHandler = DisassembleXMLFileHandler;
+    exports.ReassembleConfigFileHandler = ReassembleConfigFileHandler;
+    exports.ReassembleXMLFileHandler = ReassembleXMLFileHandler;
+
+}));
+//# sourceMappingURL=index.umd.js.map

package/dist/index.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.umd.js","sources":["../src/native-dir.ts","../src/index.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;;aAUgB,gBAAgB,CAC9B,OAAe,EACf,QAAgB,EAChB,IAAY,EAAA;QAEZ,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,MAAM;IAChD,IAAA,OAAO;IACL,UAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAA,EAAG,QAAQ,CAAA,CAAA,EAAI,IAAI,EAAE;IACpD,UAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAA,EAAG,QAAQ,IAAI,IAAI,CAAA,CAAE,CAAC;IACvE;;IChBA,MAAM,SAAS,GAAG,gBAAgB,CAChC,SAAS,EACT,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,IAAI,CACb;IACD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;UAsBlD,yBAAyB,CAAA;IACpC,IAAA,WAAW,CAAC,IAUX,EAAA;IACC,QAAA,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC;QAC/B;IACD;UAOY,wBAAwB,CAAA;IACnC,IAAA,UAAU,CAAC,IAIV,EAAA;IACC,QAAA,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC;QAC9B;IACD;UAaY,4BAA4B,CAAA;IACvC,IAAA,WAAW,CAAC,IASX,EAAA;IACC,QAAA,OAAO,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC;QAC5C;IACD;UAQY,2BAA2B,CAAA;IACtC,IAAA,UAAU,CAAC,IAKV,EAAA;IACC,QAAA,OAAO,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC;QAC3C;IACD;;;;;;;;;;;"}

package/dist/typings/index.d.ts

@@ -0,0 +1,41 @@
+export type ConfigFormat = "json" | "json5" | "jsonc" | "yaml" | "toon" | "toml" | "ini";
+export declare class DisassembleXMLFileHandler {
+    disassemble(opts: {
+        filePath: string;
+        uniqueIdElements?: string;
+        strategy?: string;
+        prePurge?: boolean;
+        postPurge?: boolean;
+        ignorePath?: string;
+        format?: string;
+        multiLevel?: string;
+        splitTags?: string;
+    }): void;
+}
+export declare class ReassembleXMLFileHandler {
+    reassemble(opts: {
+        filePath: string;
+        fileExtension?: string;
+        postPurge?: boolean;
+    }): void;
+}
+export declare class DisassembleConfigFileHandler {
+    disassemble(opts: {
+        input: string;
+        inputFormat?: ConfigFormat;
+        outputFormat?: ConfigFormat;
+        outputDir?: string;
+        uniqueId?: string;
+        prePurge?: boolean;
+        postPurge?: boolean;
+        ignorePath?: string;
+    }): string;
+}
+export declare class ReassembleConfigFileHandler {
+    reassemble(opts: {
+        inputDir: string;
+        output?: string;
+        outputFormat?: ConfigFormat;
+        postPurge?: boolean;
+    }): string;
+}

package/dist/typings/native-dir.d.ts

@@ -0,0 +1 @@
+export declare function resolveNativeDir(baseDir: string, platform: string, arch: string): string;