@loaders.gl/tile-converter 3.1.8 → 3.2.0-alpha.3

package/dist/i3s-converter/json-templates/shared-resources.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARED_RESOURCES = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const MATERIAL_DEFINITION_INFO_PARAMS = () => ({
+    renderMode: {
+        path: 'renderMode',
+        default: 'solid'
+    },
+    shininess: {
+        path: 'shininess',
+        default: 1
+    },
+    reflectivity: {
+        path: 'reflectivity',
+        default: 0
+    },
+    ambient: {
+        path: 'ambient',
+        default: [1, 1, 1, 1]
+    },
+    diffuse: {
+        path: 'diffuse',
+        default: [1, 1, 1, 1]
+    },
+    specular: {
+        path: 'specular',
+        default: [0, 0, 0, 0]
+    },
+    useVertexColorAlpha: {
+        path: 'useVertexColorAlpha',
+        default: false
+    },
+    vertexRegions: {
+        path: 'vertexRegions',
+        default: false
+    },
+    vertexColors: {
+        path: 'vertexColors',
+        default: true
+    }
+});
+const MATERIAL_DEFINITION_INFO = () => ({
+    name: {
+        path: 'name',
+        default: 'standard'
+    },
+    type: {
+        path: 'type',
+        default: 'standard'
+    },
+    params: {
+        path: 'params',
+        transform: (val, thisObject, originalObject) => (0, json_map_transform_1.default)(originalObject, MATERIAL_DEFINITION_INFO_PARAMS())
+    }
+});
+const TEXTURE_DEFINITION_IMAGE = () => ({
+    id: {
+        path: 'id'
+    },
+    size: {
+        path: 'size'
+    },
+    href: {
+        path: 'href',
+        default: ['../textures/0']
+    },
+    length: {
+        path: 'length'
+    }
+});
+const TEXTURE_DEFINITION_INFO = () => ({
+    encoding: {
+        path: 'encoding'
+    },
+    wrap: {
+        path: 'wrap',
+        default: ['none']
+    },
+    atlas: {
+        path: 'atlas',
+        default: false
+    },
+    uvSet: {
+        path: 'uvSet',
+        default: 'uv0'
+    },
+    channels: {
+        path: 'channels',
+        default: 'rgb'
+    },
+    images: {
+        path: 'images',
+        transform: (val, thisObject, originalObject) => val.map((image) => (0, json_map_transform_1.default)(image, TEXTURE_DEFINITION_IMAGE()))
+    }
+});
+const SHARED_RESOURCES = () => ({
+    materialDefinitions: {
+        path: 'materialDefinitionInfos',
+        transform: transfromMaterialDefinitions
+    },
+    textureDefinitions: {
+        path: 'textureDefinitionInfos',
+        transform: transfromTextureDefinitions
+    }
+});
+exports.SHARED_RESOURCES = SHARED_RESOURCES;
+function transfromMaterialDefinitions(materialDefinitionInfos, thisObject, originalObject) {
+    const result = {};
+    for (const [index, materialDefinitionInfo] of materialDefinitionInfos.entries()) {
+        result[`Mat${originalObject.nodePath}${index}`] = (0, json_map_transform_1.default)(materialDefinitionInfo, MATERIAL_DEFINITION_INFO());
+    }
+    return result;
+}
+function transfromTextureDefinitions(textureDefinitionInfos, thisObject, originalObject) {
+    if (!textureDefinitionInfos) {
+        return null;
+    }
+    const result = {};
+    for (const [index, textureDefinitionInfo] of textureDefinitionInfos.entries()) {
+        const imageIndex = `${originalObject.nodePath}${index}`;
+        textureDefinitionInfo.imageIndex = imageIndex;
+        result[imageIndex] = (0, json_map_transform_1.default)(textureDefinitionInfo, TEXTURE_DEFINITION_INFO());
+    }
+    return result;
+}

package/dist/i3s-converter/json-templates/store.d.ts

@@ -0,0 +1,95 @@
+export declare const STORE: {
+    id: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    profile: {
+        path: string;
+        default: string;
+    };
+    version: {
+        path: string;
+        default: string;
+    };
+    resourcePattern: {
+        path: string;
+        default: string[];
+    };
+    rootNode: {
+        path: string;
+        default: string;
+    };
+    extent: {
+        path: string;
+    };
+    indexCRS: {
+        path: string;
+        default: string;
+    };
+    vertexCRS: {
+        path: string;
+        default: string;
+    };
+    normalReferenceFrame: {
+        path: string;
+        default: string;
+    };
+    attributeEncoding: {
+        path: string;
+        default: string;
+    };
+    textureEncoding: {
+        path: string;
+        default: string[];
+    };
+    lodType: {
+        path: string;
+        default: string;
+    };
+    lodModel: {
+        path: string;
+        default: string;
+    };
+    defaultGeometrySchema: {
+        path: string;
+        default: {
+            geometryType: string;
+            header: {
+                property: string;
+                type: string;
+            }[];
+            topology: string;
+            ordering: string[];
+            vertexAttributes: {
+                position: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                normal: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                uv0: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                color: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+            };
+            featureAttributeOrder: string[];
+            featureAttributes: {
+                id: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                faceRange: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/i3s-converter/json-templates/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/store.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGjB,CAAC"}

package/dist/i3s-converter/json-templates/store.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STORE = void 0;
+exports.STORE = {
+    id: {
+        path: 'id',
+        transform: (val) => val.toUpperCase()
+    },
+    profile: {
+        path: 'profile',
+        default: 'meshpyramids'
+    },
+    version: {
+        path: 'version',
+        default: '1.8'
+    },
+    resourcePattern: {
+        path: 'resourcePattern',
+        default: ['3dNodeIndexDocument', 'Attributes', 'SharedResource', 'Geometry']
+    },
+    rootNode: {
+        path: 'rootNode',
+        default: './nodes/root'
+    },
+    extent: {
+        path: 'extent'
+    },
+    indexCRS: {
+        path: 'indexCRS',
+        default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
+    },
+    vertexCRS: {
+        path: 'vertexCRS',
+        default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
+    },
+    normalReferenceFrame: {
+        path: 'normalReferenceFrame',
+        default: 'east-north-up'
+    },
+    attributeEncoding: {
+        path: 'attributeEncoding',
+        default: 'application/octet-stream; version=1.6'
+    },
+    textureEncoding: {
+        path: 'textureEncoding',
+        default: ['image/jpeg', 'image/ktx2']
+    },
+    lodType: {
+        path: 'lodType',
+        default: 'MeshPyramid'
+    },
+    lodModel: {
+        path: 'lodModel',
+        default: 'node-switching'
+    },
+    defaultGeometrySchema: {
+        path: 'defaultGeometrySchema',
+        default: {
+            geometryType: 'triangles',
+            header: [
+                {
+                    property: 'vertexCount',
+                    type: 'UInt32'
+                },
+                {
+                    property: 'featureCount',
+                    type: 'UInt32'
+                }
+            ],
+            topology: 'PerAttributeArray',
+            ordering: ['position', 'normal', 'uv0', 'color'],
+            vertexAttributes: {
+                position: {
+                    valueType: 'Float32',
+                    valuesPerElement: 3
+                },
+                normal: {
+                    valueType: 'Float32',
+                    valuesPerElement: 3
+                },
+                uv0: {
+                    valueType: 'Float32',
+                    valuesPerElement: 2
+                },
+                color: {
+                    valueType: 'UInt8',
+                    valuesPerElement: 4
+                }
+            },
+            featureAttributeOrder: ['id', 'faceRange'],
+            featureAttributes: {
+                id: {
+                    valueType: 'UInt64',
+                    valuesPerElement: 1
+                },
+                faceRange: {
+                    valueType: 'UInt32',
+                    valuesPerElement: 2
+                }
+            }
+        }
+    }
+};

package/dist/i3s-converter/types.d.ts

@@ -0,0 +1,114 @@
+import { BoundingVolumes, I3SMaterialDefinition, MaterialDefinitionInfo, TextureDefinitionInfo } from '@loaders.gl/i3s';
+import { ImageDataType } from '@loaders.gl/images';
+/** Converted resources for specific node */
+export declare type I3SConvertedResources = {
+    /** Non-compressed geometry buffer that have structure met
+     * https://github.com/Esri/i3s-spec/blob/master/docs/1.8/defaultGeometrySchema.cmn.md
+     * (Geometry buffer)
+     */
+    geometry: ArrayBuffer | null;
+    /**
+     * Draco compressed geometry
+     */
+    compressedGeometry?: Promise<ArrayBuffer> | null;
+    /**
+     * Texture image content
+     */
+    texture: any | null;
+    /**
+     * Shared resources built from GLTF material
+     */
+    sharedResources: SharedResourcesArrays | null;
+    /**
+     * Material definition of the node
+     */
+    meshMaterial?: I3SMaterialDefinition | null;
+    /**
+     * Number of vertices in the node
+     */
+    vertexCount: number | null;
+    /**
+     * Feature attributes contents
+     */
+    attributes: ArrayBuffer[] | null;
+    /**
+     * Number of features in the node
+     */
+    featureCount: number | null;
+    /**
+     * MBS and/or OBB bounding volumes of the node
+     */
+    boundingVolumes: BoundingVolumes | null;
+};
+/**
+ * Geometry and feature attributes converted from GLTF primitives
+ */
+export declare type ConvertedAttributes = {
+    /** POSITION attribute value */
+    positions: Float32Array;
+    /** NORMAL attribute value */
+    normals: Float32Array;
+    /** TEXCOORD_0 attribute value */
+    texCoords: Float32Array;
+    /** COLOR_0 attribute value */
+    colors: Uint8Array;
+    /** Feature indices grouped by ...
+     * converted from "batch ids" of GLTF
+     */
+    featureIndicesGroups?: number[][];
+    /** Feature indices converted from "batch ids" */
+    featureIndices: number[];
+    /**
+     * MBS and/or OBB bounding volumes of the node
+     */
+    boundingVolumes: null | BoundingVolumes;
+};
+/** Postprocessed geometry and feature attributes
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.8/defaultGeometrySchema.cmn.md
+ */
+export declare type GeometryAttributes = {
+    /** POSITION attribute value */
+    positions: Float32Array;
+    /** NORMAL attribute value */
+    normals: Float32Array;
+    /** TEXCOORD_0 attribute value */
+    texCoords: Float32Array;
+    /** COLOR_0 attribute value */
+    colors: Uint8Array;
+    /** faceRanges attribute value  */
+    faceRange: Uint32Array;
+    /** feature Ids attribute value */
+    featureIds: number[];
+    /** number of features in the node */
+    featureCount: number;
+};
+/** Geometry attributes specific for the particular feature */
+export declare type GroupedByFeatureIdAttributes = {
+    /** Feature Id */
+    featureId: number;
+    /** POSITION attribute value */
+    positions: Float32Array;
+    /** NORMAL attribute value */
+    normals: Float32Array;
+    /** COLOR_0 attribute value */
+    colors: Uint8Array;
+    /** TEXCOORD_0 attribute value */
+    texCoords: Float32Array;
+};
+/** Shared resources made from GLTF material */
+export declare type SharedResourcesArrays = {
+    /** material definitions list https://github.com/Esri/i3s-spec/blob/master/docs/1.8/materialDefinitionInfo.cmn.md */
+    materialDefinitionInfos?: MaterialDefinitionInfo[];
+    /** texture definitions list  https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureDefinitionInfo.cmn.md*/
+    textureDefinitionInfos?: TextureDefinitionInfo[];
+    /** node id to make unique SharedResource ids */
+    nodePath?: string;
+};
+/** I3S material definition and texture content taken from GLTF material */
+export declare type I3SMaterialWithTexture = {
+    /** Material definition https://github.com/Esri/i3s-spec/blob/master/docs/1.8/materialDefinitions.cmn.md */
+    material: I3SMaterialDefinition;
+    /** Texture content (image) */
+    texture?: ImageDataType;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/i3s-converter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/i3s-converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEjD,4CAA4C;AAC5C,oBAAY,qBAAqB,GAAG;IAClC;;;OAGG;IACH,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAC7B;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IACjD;;OAEG;IACH,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IACpB;;OAEG;IACH,eAAe,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC9C;;OAEG;IACH,YAAY,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC5C;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;OAEG;IACH,UAAU,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IACjC;;OAEG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;OAEG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;CACzC,CAAC;AAEF;;GAEG;AACH,oBAAY,mBAAmB,GAAG;IAChC,+BAA+B;IAC/B,SAAS,EAAE,YAAY,CAAC;IACxB,6BAA6B;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,iCAAiC;IACjC,SAAS,EAAE,YAAY,CAAC;IACxB,8BAA8B;IAC9B,MAAM,EAAE,UAAU,CAAC;IACnB;;OAEG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAClC,iDAAiD;IACjD,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB;;OAEG;IACH,eAAe,EAAE,IAAI,GAAG,eAAe,CAAC;CACzC,CAAC;AAEF;;GAEG;AACH,oBAAY,kBAAkB,GAAG;IAC/B,+BAA+B;IAC/B,SAAS,EAAE,YAAY,CAAC;IACxB,6BAA6B;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,iCAAiC;IACjC,SAAS,EAAE,YAAY,CAAC;IACxB,8BAA8B;IAC9B,MAAM,EAAE,UAAU,CAAC;IACnB,kCAAkC;IAClC,SAAS,EAAE,WAAW,CAAC;IACvB,kCAAkC;IAClC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,8DAA8D;AAC9D,oBAAY,4BAA4B,GAAG;IACzC,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,SAAS,EAAE,YAAY,CAAC;IACxB,6BAA6B;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,8BAA8B;IAC9B,MAAM,EAAE,UAAU,CAAC;IACnB,iCAAiC;IACjC,SAAS,EAAE,YAAY,CAAC;CACzB,CAAC;AAEF,+CAA+C;AAC/C,oBAAY,qBAAqB,GAAG;IAClC,oHAAoH;IACpH,uBAAuB,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACnD,kHAAkH;IAClH,sBAAsB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACjD,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,2EAA2E;AAC3E,oBAAY,sBAAsB,GAAG;IACnC,2GAA2G;IAC3G,QAAQ,EAAE,qBAAqB,CAAC;IAChC,8BAA8B;IAC9B,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CAAC"}

package/dist/i3s-converter/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/i3s-server/app.d.ts

@@ -0,0 +1,3 @@
+export = app;
+declare const app: any;
+//# sourceMappingURL=app.d.ts.map

package/dist/i3s-server/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/i3s-server/app.js"],"names":[],"mappings":";AAOA,uBAAsB"}

package/dist/i3s-server/app.js

@@ -0,0 +1,14 @@
+"use strict";
+const express = require('express');
+const path = require('path');
+const logger = require('morgan');
+const cors = require('cors');
+const indexRouter = require('./routes/index');
+const app = express();
+app.use(logger('dev'));
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(cors());
+app.use('/', indexRouter);
+module.exports = app;

package/dist/i3s-server/controllers/index-controller.d.ts

@@ -0,0 +1,2 @@
+export function getFileNameByUrl(url: any): Promise<string | null>;
+//# sourceMappingURL=index-controller.d.ts.map

package/dist/i3s-server/controllers/index-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-controller.d.ts","sourceRoot":"","sources":["../../../src/i3s-server/controllers/index-controller.js"],"names":[],"mappings":"AAQA,mEAYC"}

package/dist/i3s-server/controllers/index-controller.js

@@ -0,0 +1,23 @@
+"use strict";
+const path = require('path');
+const fs = require('fs');
+const { promises } = fs;
+const I3S_LAYER_PATH = process.env.I3sLayerPath || ''; // eslint-disable-line no-process-env, no-undef
+const FULL_LAYER_PATH = path.join(process.cwd(), I3S_LAYER_PATH); // eslint-disable-line no-undef
+async function getFileNameByUrl(url) {
+    const extensions = ['json', 'bin', 'jpg', 'jpeg', 'png', 'bin.dds', 'ktx2'];
+    for (const ext of extensions) {
+        const fileName = `${FULL_LAYER_PATH}${url}/index.${ext}`;
+        try {
+            await promises.access(fileName);
+            return fileName;
+        }
+        catch {
+            continue; // eslint-disable-line no-continue
+        }
+    }
+    return null;
+}
+module.exports = {
+    getFileNameByUrl
+};

package/dist/i3s-server/routes/index.d.ts

@@ -0,0 +1,3 @@
+export = router;
+declare const router: any;
+//# sourceMappingURL=index.d.ts.map

package/dist/i3s-server/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/i3s-server/routes/index.js"],"names":[],"mappings":";AACA,0BAAgC"}

package/dist/i3s-server/routes/index.js

@@ -0,0 +1,16 @@
+"use strict";
+const express = require('express');
+const router = express.Router();
+const { getFileNameByUrl } = require('../controllers/index-controller');
+/* GET home page. */
+router.get('*', async function (req, res, next) {
+    const fileName = await getFileNameByUrl(req.path);
+    if (fileName) {
+        res.sendFile(fileName);
+    }
+    else {
+        res.status(404);
+        res.send('File not found');
+    }
+});
+module.exports = router;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as I3SConverter } from './i3s-converter/i3s-converter';
+export { default as Tiles3DConverter } from './3d-tiles-converter/3d-tiles-converter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,yCAAyC,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tiles3DConverter = exports.I3SConverter = void 0;
+var i3s_converter_1 = require("./i3s-converter/i3s-converter");
+Object.defineProperty(exports, "I3SConverter", { enumerable: true, get: function () { return __importDefault(i3s_converter_1).default; } });
+var _3d_tiles_converter_1 = require("./3d-tiles-converter/3d-tiles-converter");
+Object.defineProperty(exports, "Tiles3DConverter", { enumerable: true, get: function () { return __importDefault(_3d_tiles_converter_1).default; } });

package/dist/lib/utils/compress-util.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Compress file to gzip file
+ *
+ * @param pathFile - the path to the file
+ * @return the path to the gzip file
+ */
+export declare function compressFileWithGzip(pathFile: string): Promise<string>;
+/**
+ * Compress files from map into slpk file
+ *
+ * @param fileMap - map with file paths (key: output path, value: input path)
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ */
+export declare function compressFilesWithZip(fileMap: {
+    [key: string]: string;
+}, outputFile: string, level?: number): Promise<unknown>;
+/**
+ * Compress files using external tool 'zip'/'7z'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ * @param sevenZipExe - path to 7z.exe executable
+ */
+export declare function compressWithChildProcess(inputFolder: string, outputFile: string, level: number, inputFiles: string, sevenZipExe: string): Promise<void>;
+/**
+ * Generate hash file from zip archive
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/slpk_hashtable.cmn.md
+ *
+ * @param inputZipFile
+ * @param outputFile
+ */
+export declare function generateHash128FromZip(inputZipFile: string, outputFile: string): Promise<unknown>;
+/**
+ * Add file to zip archive
+ *
+ * @param inputFile
+ * @param fileName
+ * @param zipFile
+ * @param sevenZipExe
+ */
+export declare function addFileToZip(inputFolder: string, fileName: string, zipFile: string, sevenZipExe: string): Promise<void>;
+//# sourceMappingURL=compress-util.d.ts.map

package/dist/lib/utils/compress-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-util.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/compress-util.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBtE;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,EAChC,UAAU,EAAE,MAAM,EAClB,KAAK,GAAE,MAAU,oBAqDlB;AAED;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,iBAQpB;AAgED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBA6CpF;AAeD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,iBAIpB"}