@fgv/ts-extras 5.0.1-9 → 5.0.1

package/dist/packlets/zip-file-tree/index.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * 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.
+ */
+/**
+ * ZIP-based FileTree implementation for ts-extras.
+ *
+ * This packlet provides a FileTree accessor implementation that can read from ZIP archives,
+ * making it useful for browser environments where files need to be bundled and transferred
+ * as a single archive.
+ *
+ * @packageDocumentation
+ */
+export { ZipFileTreeAccessors, ZipFileItem, ZipDirectoryItem } from './zipFileTreeAccessors';
+//# sourceMappingURL=index.js.map

package/dist/packlets/zip-file-tree/zipFileTreeAccessors.js

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * 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.
+ */
+import { unzipSync, unzip } from 'fflate';
+import { succeed, fail, captureResult } from '@fgv/ts-utils';
+/**
+ * Implementation of `FileTree.IFileTreeFileItem` for files in a ZIP archive.
+ * @public
+ */
+export class ZipFileItem {
+    /**
+     * The content type of the file.
+     */
+    get contentType() {
+        if (this._contentType === undefined && this._shouldInferContentType) {
+            this._contentType = this._accessors.getFileContentType(this.absolutePath).orDefault();
+            this._shouldInferContentType = false;
+        }
+        return this._contentType;
+    }
+    /**
+     * Constructor for ZipFileItem.
+     * @param zipFilePath - The path of the file within the ZIP.
+     * @param contents - The pre-loaded contents of the file.
+     * @param accessors - The ZIP file tree accessors.
+     */
+    constructor(zipFilePath, contents, accessors) {
+        /**
+         * Indicates that this `FileTree.FileTreeItem` is a file.
+         */
+        this.type = 'file';
+        /**
+         * Flag to track if content type should be inferred on first access.
+         */
+        this._shouldInferContentType = true;
+        this._contents = contents;
+        this._accessors = accessors;
+        this.absolutePath = '/' + zipFilePath;
+        this.name = accessors.getBaseName(zipFilePath);
+        this.extension = accessors.getExtension(zipFilePath);
+        this.baseName = accessors.getBaseName(zipFilePath, this.extension);
+    }
+    /**
+     * Sets the content type of the file.
+     * @param contentType - The content type of the file.
+     */
+    setContentType(contentType) {
+        this._contentType = contentType;
+        this._shouldInferContentType = false;
+    }
+    getContents(converter) {
+        return this.getRawContents()
+            .onSuccess((contents) => {
+            return captureResult(() => JSON.parse(contents))
+                .onSuccess((parsed) => {
+                if (converter) {
+                    return converter.convert(parsed);
+                }
+                return succeed(parsed);
+            })
+                .onFailure(() => {
+                return fail(`Failed to parse JSON from file: ${this.absolutePath}`);
+            });
+        })
+            .onFailure((error) => {
+            return fail(`Failed to get contents from file: ${error}`);
+        });
+    }
+    /**
+     * Gets the raw contents of the file as a string.
+     */
+    getRawContents() {
+        return succeed(this._contents);
+    }
+}
+/**
+ * Implementation of `IFileTreeDirectoryItem` for directories in a ZIP archive.
+ * @public
+ */
+export class ZipDirectoryItem {
+    /**
+     * Constructor for ZipDirectoryItem.
+     * @param directoryPath - The path of the directory within the ZIP.
+     * @param accessors - The ZIP file tree accessors.
+     */
+    constructor(directoryPath, accessors) {
+        /**
+         * Indicates that this `FileTree.FileTreeItem` is a directory.
+         */
+        this.type = 'directory';
+        this._accessors = accessors;
+        this.absolutePath = '/' + directoryPath.replace(/\/$/, ''); // Normalize path
+        this.name = accessors.getBaseName(directoryPath);
+    }
+    /**
+     * Gets the children of the directory.
+     */
+    getChildren() {
+        return this._accessors.getChildren(this.absolutePath);
+    }
+}
+/**
+ * File tree accessors for ZIP archives.
+ * @public
+ */
+export class ZipFileTreeAccessors {
+    /**
+     * Constructor for ZipFileTreeAccessors.
+     * @param files - The unzipped file data from fflate.
+     * @param params - Optional initialization parameters.
+     */
+    constructor(files, params) {
+        var _a;
+        /**
+         * Cache of all items in the ZIP for efficient lookups.
+         */
+        this._itemCache = new Map();
+        this._files = files;
+        this._prefix = (params === null || params === void 0 ? void 0 : params.prefix) || '';
+        this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : ZipFileTreeAccessors.defaultInferContentType;
+        this._buildItemCache();
+    }
+    /**
+     * Default function to infer the content type of a file.
+     * @param filePath - The path of the file.
+     * @param provided - Optional supplied content type.
+     * @returns `Success` with the content type of the file if successful, or
+     * `Failure` with an error message otherwise.
+     * @remarks This default implementation always returns `Success` with `undefined`.
+     * @public
+     */
+    static defaultInferContentType(__filePath, __provided) {
+        return succeed(undefined);
+    }
+    static fromBuffer(zipBuffer, params) {
+        try {
+            /* c8 ignore next 1 - defense in depth */
+            const uint8Buffer = zipBuffer instanceof Uint8Array ? zipBuffer : new Uint8Array(zipBuffer);
+            const files = unzipSync(uint8Buffer);
+            const normalizedParams = typeof params === 'string' ? { prefix: params } : params;
+            return succeed(new ZipFileTreeAccessors(files, normalizedParams));
+        }
+        catch (error) {
+            /* c8 ignore next 1 - defensive coding: fflate always throws Error objects in practice */
+            return fail(`Failed to load ZIP archive: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    static async fromBufferAsync(zipBuffer, params) {
+        return new Promise((resolve) => {
+            try {
+                /* c8 ignore next 1 - defense in depth */
+                const uint8Buffer = zipBuffer instanceof Uint8Array ? zipBuffer : new Uint8Array(zipBuffer);
+                unzip(uint8Buffer, (err, files) => {
+                    if (err) {
+                        resolve(fail(`Failed to load ZIP archive: ${err.message}`));
+                    }
+                    else {
+                        const normalizedParams = typeof params === 'string' ? { prefix: params } : params;
+                        resolve(succeed(new ZipFileTreeAccessors(files, normalizedParams)));
+                    }
+                });
+                /* c8 ignore next 6 - defensive coding: fflate reports errors via callback, not exceptions */
+            }
+            catch (error) {
+                resolve(fail(`Failed to load ZIP archive: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+    }
+    /**
+     * Creates a new ZipFileTreeAccessors instance from a File object (browser environment).
+     * @param file - The File object containing ZIP data.
+     * @param params - Optional initialization parameters.
+     * @returns Result containing the ZipFileTreeAccessors instance.
+     */
+    static async fromFile(file, params) {
+        try {
+            const arrayBuffer = await file.arrayBuffer();
+            const uint8Buffer = new Uint8Array(arrayBuffer);
+            return await ZipFileTreeAccessors.fromBufferAsync(uint8Buffer, params);
+        }
+        catch (error) {
+            return fail(`Failed to read file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Builds the cache of all items in the ZIP archive.
+     */
+    _buildItemCache() {
+        const directories = new Set();
+        // Process all files and collect directory paths
+        for (const [relativePath, fileData] of Object.entries(this._files)) {
+            // Skip directories in fflate output (they have null data)
+            /* c8 ignore next 5 - handles explicit directory entries from external ZIP tools (fflate doesn't create these) */
+            if (fileData === null || fileData === undefined) {
+                const dirPath = relativePath.replace(/\/$/, '');
+                if (dirPath) {
+                    directories.add(dirPath);
+                }
+            }
+            else {
+                // Extract directory paths from file paths
+                const pathParts = relativePath.split('/');
+                for (let i = 1; i < pathParts.length; i++) {
+                    const dirPath = pathParts.slice(0, i).join('/');
+                    if (dirPath) {
+                        directories.add(dirPath);
+                    }
+                }
+                // Add the file item with its contents
+                const absolutePath = this.resolveAbsolutePath(relativePath);
+                const contents = new TextDecoder().decode(fileData);
+                const item = new ZipFileItem(relativePath, contents, this);
+                this._itemCache.set(absolutePath, item);
+            }
+        }
+        // Add directory items to cache
+        directories.forEach((dirPath) => {
+            const absolutePath = this.resolveAbsolutePath(dirPath);
+            const item = new ZipDirectoryItem(dirPath, this);
+            this._itemCache.set(absolutePath, item);
+        });
+    }
+    /**
+     * Resolves paths to an absolute path.
+     */
+    resolveAbsolutePath(...paths) {
+        const joinedPath = this.joinPaths(...paths);
+        const prefixed = this._prefix ? this.joinPaths(this._prefix, joinedPath) : joinedPath;
+        return prefixed.startsWith('/') ? prefixed : '/' + prefixed;
+    }
+    /**
+     * Gets the extension of a path.
+     */
+    getExtension(path) {
+        const name = this.getBaseName(path);
+        const lastDotIndex = name.lastIndexOf('.');
+        return lastDotIndex >= 0 ? name.substring(lastDotIndex) : '';
+    }
+    /**
+     * Gets the base name of a path.
+     */
+    getBaseName(path, suffix) {
+        const normalizedPath = path.replace(/\/$/, ''); // Remove trailing slash
+        const parts = normalizedPath.split('/');
+        let baseName = parts[parts.length - 1] || '';
+        if (suffix && baseName.endsWith(suffix)) {
+            baseName = baseName.substring(0, baseName.length - suffix.length);
+        }
+        return baseName;
+    }
+    /**
+     * Joins paths together.
+     */
+    joinPaths(...paths) {
+        return paths
+            .filter((p) => p && p.length > 0)
+            .map((p) => p.replace(/^\/+|\/+$/g, '')) // Remove leading/trailing slashes
+            .join('/')
+            .replace(/\/+/g, '/'); // Normalize multiple slashes
+    }
+    /**
+     * Gets an item from the file tree.
+     */
+    getItem(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const item = this._itemCache.get(absolutePath);
+        if (item) {
+            return succeed(item);
+        }
+        return fail(`Item not found: ${absolutePath}`);
+    }
+    /**
+     * Gets the contents of a file in the file tree.
+     */
+    getFileContents(path) {
+        return this.getItem(path).onSuccess((item) => {
+            if (item.type !== 'file') {
+                return fail(`Path is not a file: ${path}`);
+            }
+            return item.getRawContents();
+        });
+    }
+    /**
+     * Gets the content type of a file in the file tree.
+     */
+    getFileContentType(path, provided) {
+        // If provided contentType is given, use it directly (highest priority)
+        if (provided !== undefined) {
+            return succeed(provided);
+        }
+        // For files that exist in the ZIP, we don't store explicit contentType
+        // so we always fall back to inference
+        return this._inferContentType(path);
+    }
+    /**
+     * Gets the children of a directory in the file tree.
+     */
+    getChildren(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const children = [];
+        // Find all items that are direct children of this directory
+        for (const [itemPath, item] of this._itemCache) {
+            if (this._isDirectChild(absolutePath, itemPath)) {
+                children.push(item);
+            }
+        }
+        return succeed(children);
+    }
+    /**
+     * Checks if childPath is a direct child of parentPath.
+     */
+    _isDirectChild(parentPath, childPath) {
+        // Normalize paths
+        const normalizedParent = parentPath.replace(/\/$/, '');
+        const normalizedChild = childPath.replace(/\/$/, '');
+        // Child must start with parent path
+        if (!normalizedChild.startsWith(normalizedParent + '/')) {
+            return false;
+        }
+        // Get the relative path from parent to child
+        const relativePath = normalizedChild.substring(normalizedParent.length + 1);
+        // Direct child means no additional slashes in the relative path
+        return !relativePath.includes('/');
+    }
+}
+//# sourceMappingURL=zipFileTreeAccessors.js.map

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.53.3"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/lib/index.browser.d.ts

@@ -1,6 +1,8 @@
+import * as Csv from './packlets/csv/index.browser';
 import * as Experimental from './packlets/experimental';
 import * as Hash from './packlets/hash/index.browser';
+import * as RecordJar from './packlets/record-jar/index.browser';
 import * as ZipFileTree from './packlets/zip-file-tree';
 import { Converters } from './packlets/conversion';
-export { Converters, Experimental, Hash, ZipFileTree };
+export { Converters, Csv, Experimental, Hash, RecordJar, ZipFileTree };
 //# sourceMappingURL=index.browser.d.ts.map

package/lib/index.browser.js

@@ -54,13 +54,19 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZipFileTree = exports.Hash = exports.Experimental = exports.Converters = void 0;
+exports.ZipFileTree = exports.RecordJar = exports.Hash = exports.Experimental = exports.Csv = exports.Converters = void 0;
 /* c8 ignore start - Browser-specific export used conditionally in package.json */
+// eslint-disable-next-line @rushstack/packlets/mechanics
+const Csv = __importStar(require("./packlets/csv/index.browser"));
+exports.Csv = Csv;
 const Experimental = __importStar(require("./packlets/experimental"));
 exports.Experimental = Experimental;
 // eslint-disable-next-line @rushstack/packlets/mechanics
 const Hash = __importStar(require("./packlets/hash/index.browser"));
 exports.Hash = Hash;
+// eslint-disable-next-line @rushstack/packlets/mechanics
+const RecordJar = __importStar(require("./packlets/record-jar/index.browser"));
+exports.RecordJar = RecordJar;
 const ZipFileTree = __importStar(require("./packlets/zip-file-tree"));
 exports.ZipFileTree = ZipFileTree;
 const conversion_1 = require("./packlets/conversion");

package/lib/packlets/csv/index.browser.d.ts

@@ -0,0 +1,3 @@
+export * from './csvHelpers';
+export { readCsvFromTree } from './csvFileHelpers';
+//# sourceMappingURL=index.browser.d.ts.map

package/lib/packlets/csv/index.browser.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCsvFromTree = void 0;
+// Browser-safe CSV exports - excludes Node.js filesystem dependencies
+// Export all browser-safe parsing functionality
+__exportStar(require("./csvHelpers"), exports);
+// Export FileTree-based reading (web-compatible)
+var csvFileHelpers_1 = require("./csvFileHelpers");
+Object.defineProperty(exports, "readCsvFromTree", { enumerable: true, get: function () { return csvFileHelpers_1.readCsvFromTree; } });
+// Exclude:
+// - readCsvFileSync (requires Node.js fs/path)
+//# sourceMappingURL=index.browser.js.map

package/lib/packlets/record-jar/index.browser.d.ts

@@ -0,0 +1,3 @@
+export * from './recordJarHelpers';
+export { readRecordJarFromTree } from './recordJarFileHelpers';
+//# sourceMappingURL=index.browser.d.ts.map

package/lib/packlets/record-jar/index.browser.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright (c) 2023 Erik Fortune
+ *
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRecordJarFromTree = void 0;
+// Browser-safe RecordJar exports - excludes Node.js filesystem dependencies
+// Export all browser-safe parsing functionality
+__exportStar(require("./recordJarHelpers"), exports);
+// Export FileTree-based reading (web-compatible)
+var recordJarFileHelpers_1 = require("./recordJarFileHelpers");
+Object.defineProperty(exports, "readRecordJarFromTree", { enumerable: true, get: function () { return recordJarFileHelpers_1.readRecordJarFromTree; } });
+// Exclude:
+// - readRecordJarFileSync (requires Node.js fs/path)
+//# sourceMappingURL=index.browser.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-extras",
-  "version": "5.0.1-9",
+  "version": "5.0.1",
   "description": "Assorted Typescript Utilities",
   "main": "lib/index.js",
   "types": "dist/ts-extras.d.ts",
@@ -68,18 +68,19 @@
     "@types/heft-jest": "1.0.6",
     "@rushstack/heft-jest-plugin": "1.1.3",
     "eslint-plugin-tsdoc": "~0.4.0",
-    "@fgv/ts-utils-jest": "5.0.1-9",
-    "@fgv/ts-utils": "5.0.1-9"
+    "@fgv/heft-dual-rig": "0.1.0",
+    "@fgv/ts-utils-jest": "5.0.1",
+    "@fgv/ts-utils": "5.0.1"
   },
   "dependencies": {
     "luxon": "^3.7.2",
     "mustache": "^4.2.0",
     "papaparse": "^5.4.1",
     "fflate": "~0.8.2",
-    "@fgv/ts-json-base": "5.0.1-9"
+    "@fgv/ts-json-base": "5.0.1"
   },
   "peerDependencies": {
-    "@fgv/ts-utils": "5.0.1-9"
+    "@fgv/ts-utils": "5.0.1"
   },
   "scripts": {
     "build": "heft build --clean",