@loaders.gl/zip 4.0.4 → 4.1.0-alpha.10

package/src/parse-zip/zip64-info-generation.ts

@@ -0,0 +1,106 @@
+import {concatenateArrayBuffers} from '@loaders.gl/loader-utils';
+
+export const signature = new Uint8Array([0x01, 0x00]);
+
+/** info that can be placed into zip64 field, doc: https://en.wikipedia.org/wiki/ZIP_(file_format)#ZIP64 */
+type Zip64Options = {
+  /** Original uncompressed file size and Size of compressed data */
+  size?: number;
+  /** Offset of local header record */
+  offset?: number;
+};
+
+/**
+ * creates zip64 extra field
+ * @param options info that can be placed into zip64 field
+ * @returns buffer with field
+ */
+export function createZip64Info(options: Zip64Options): ArrayBuffer {
+  const optionsToUse = {
+    ...options,
+    zip64Length: (options.offset ? 1 : 0) * 8 + (options.size ? 1 : 0) * 16
+  };
+
+  const arraysToConcat: ArrayBuffer[] = [];
+
+  for (const field of ZIP64_FIELDS) {
+    if (!optionsToUse[field.name ?? ''] && !field.default) {
+      continue;
+    }
+    const newValue = new DataView(new ArrayBuffer(field.size));
+    NUMBER_SETTERS[field.size](newValue, 0, optionsToUse[field.name ?? ''] ?? field.default);
+    arraysToConcat.push(newValue.buffer);
+  }
+
+  return concatenateArrayBuffers(...arraysToConcat);
+}
+
+/**
+ * Function to write values into buffer
+ * @param header buffer where to write a value
+ * @param offset offset of the writing start
+ * @param value value to be written
+ */
+type NumberSetter = (header: DataView, offset: number, value: number | bigint) => void;
+
+/**
+ * Writes values into buffer according to the bytes amount
+ * @param header header where to write the data
+ * @param fieldSize size of the field in bytes
+ * @param fieldOffset offset of the field
+ * @param value value to be written
+ */
+export function setFieldToNumber(
+  header: DataView,
+  fieldSize: number,
+  fieldOffset: number | bigint,
+  value: number | bigint
+): void {
+  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
+}
+
+/** functions to write values into buffer according to the bytes amount */
+const NUMBER_SETTERS: {[key: number]: NumberSetter} = {
+  2: (header, offset, value) => {
+    header.setUint16(offset, Number(value), true);
+  },
+  4: (header, offset, value) => {
+    header.setUint32(offset, Number(value), true);
+  },
+  8: (header, offset, value) => {
+    header.setBigUint64(offset, BigInt(value), true);
+  }
+};
+
+/** zip64 info fields description, we need it as a pattern to build a zip64 info */
+const ZIP64_FIELDS = [
+  // Header ID 0x0001
+  {
+    size: 2,
+    default: new DataView(signature.buffer).getUint16(0, true)
+  },
+
+  // Size of the extra field chunk (8, 16, 24 or 28)
+  {
+    size: 2,
+    name: 'zip64Length'
+  },
+
+  // Original uncompressed file size
+  {
+    size: 8,
+    name: 'size'
+  },
+
+  // Size of compressed data
+  {
+    size: 8,
+    name: 'size'
+  },
+
+  // Offset of local header record
+  {
+    size: 8,
+    name: 'offset'
+  }
+];

package/src/tar-builder.ts

@@ -1,4 +1,5 @@
-// loaders.gl, MIT license
+// loaders.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import Tar from './lib/tar/tar';

package/src/zip-loader.ts

@@ -1,4 +1,5 @@
-// loaders.gl, MIT license
+// loaders.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';

package/src/zip-writer.ts

@@ -1,9 +1,13 @@
-// loaders.gl, MIT license
+// loaders.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
+import type {WriterWithEncoder, WriterOptions} from '@loaders.gl/loader-utils';
 import JSZip, {JSZipGeneratorOptions} from 'jszip';
 
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
 export type ZipWriterOptions = WriterOptions & {
   zip?: {
     onUpdate?: (metadata: {percent: number}) => void;
@@ -15,19 +19,27 @@ export type ZipWriterOptions = WriterOptions & {
 /**
  * Zip exporter
  */
-export const ZipWriter: Writer<FileReaderEventMap, never, ZipWriterOptions> = {
+export const ZipWriter: WriterWithEncoder<Record<string, ArrayBuffer>, never, ZipWriterOptions> = {
   name: 'Zip Archive',
+  id: 'zip',
+  module: 'zip',
+  version: VERSION,
   extensions: ['zip'],
   category: 'archive',
   mimeTypes: ['application/zip'],
-  // @ts-ignore
+  options: {
+    zip: {
+      onUpdate: () => {}
+    },
+    jszip: {}
+  },
   encode: encodeZipAsync
 };
 
 async function encodeZipAsync(
   fileMap: Record<string, ArrayBuffer>,
   options: ZipWriterOptions = {}
-) {
+): Promise<ArrayBuffer> {
   const jsZip = new JSZip();
   // add files to the zip
   for (const subFileName in fileMap) {
@@ -38,14 +50,16 @@ async function encodeZipAsync(
     jsZip.file(subFileName, subFileData, options?.jszip || {});
   }
 
-  // always generate the full zip as an arraybuffer
-  const jszipOptions: JSZipGeneratorOptions = {...options?.jszip, type: 'arraybuffer'};
-  const {onUpdate = () => {}} = options;
+  const zipOptions = {...ZipWriter.options.zip, ...options?.zip};
+  const jszipOptions: JSZipGeneratorOptions = {...ZipWriter.options?.jszip, ...options.jszip};
 
   try {
-    return await jsZip.generateAsync(jszipOptions, onUpdate);
+    return await jsZip.generateAsync(
+      {...jszipOptions, type: 'arraybuffer'}, // generate an arraybuffer
+      zipOptions.onUpdate
+    );
   } catch (error) {
-    options.log.error(`Unable to write zip archive: ${error}`);
+    options.log.error(`Unable to encode zip archive: ${error}`);
     throw error;
   }
 }