New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →

jsziptools

Package Overview

Dependencies

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

jsziptools

It's a utility of zlib, gzip and zip format binary data.

3.0.0-rc1
Source
npm

Version published: 7 years ago

Weekly downloads: 0; decreased by-100%

Maintainers: 1

Weekly downloads

Created: 7 years ago

Source

jsziptools

It's a utility of zlib, gzip and zip format binary data.

suported browser

chrome, firefox, Edge, safari, opera.

examples

web examples

APIs

common

BufferLike

@type {string | number[] | ArrayBuffer | Uint8Array | Int8Array | Uint8ClampedArray}

jz.common.toBytes(buffer)

@param {BufferLike} buffer
@return {Uint8Array}

jz.common.readFileAsArrayBuffer(blob)

@param {Blob} blob
@return {Promise<ArrayBuffer>}

jz.common.readFileAsArrayBuffer(blob).then(buffer => {
  // ...
});

jz.common.readFileAsText(blob, encoding)

@param {Blob} blob
@param {string} encoding - optional (default is "UTF-8")
@return {Promise<string>}

jz.common.readFileAsDataURL(blob)

@param {Blob} blob
@return {Promise<string>}

jz.common.bytesToString(buffer)

@param {BufferLike} buffer
@return {Promise<string>}

jz.common.bytesToString(bytes).then(str => {
  // ...
});

jz.common.concatBytes(buffers)

@param {Array<BufferLike>} buffers
@return {Uint8Array}

let concated = jz.common.concatBytes([bytes1, bytes2]);
// or
let concated = jz.common.concatBytes(bytes1, bytes2);

jz.common.load(urls)

It loads files as Uint8Array.

@param {Array<string>} urls
@return {Promise<Uint8Array[]>}

jz.common.load(['foo.png', 'bar.jpg']).then(([foo, bar]) => {
  // ...
});
// or
jz.common.load('foo.png', 'bar.jpg').then(([foo, bar]) => {
  // ...
});

core

jz.core.deflate({buffer, level, chunkSize})

@param {BufferLike} buffer
@param {number} level - optional (default is 6, range is 0-9)
@param {number} chunkSize - optional (default is 0x8000)
@return {Uint8Array}

jz.core.inflate({buffer, chunkSize})

@param {BufferLike} buffer
@param {number} chunkSize - optional (default is 0x8000)
@return {Uint8Array}

jz.core.adler32(buffer)

@param {BufferLike} buffer
@return {number}

jz.core.crc32({buffer, crc})

@param {BufferLike} buffer
@param {number}
@return {number}

jz.stream.core.deflate({buffer, streamFn, level, shareMemory, chunkSize})

@param {BufferLike} buffer
@param {function(chunk: Uint8Array)} streamFn
@param {number} level - optional (default is 6)
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)

jz.stream.core.deflate({
  buffer: buffer,
  streamFn: chunk => {
    // ...
  },
  shareMemory: false,
});

jz.steram.core.inflate({buffer, streamFn, shareMemory, chunkSize})

@param {BufferLike} buffer
@param {function(chunk: Uint8Array)} streamFn
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)

zlib

jz.zlib.compress({buffer, level, chunkSize})

@param {BufferLike} buffer
@param {number} level - optional (default is 6)
@param {number} chunkSize - optional (default is 0x8000)
@return {Uint8Array}

jz.zlib.decompress({buffer, chunkSize})

@param {BufferLike} buffer
@param {number} chunkSize - optional (default is 0x8000)
@return {Uint8Array}

jz.stream.zlib.compress({buffer, streamFn, level, shareMemory, chunkSize})

@param {BufferLike} buffer
@param {function(chunk: Uint8Array)} streamFn
@param {number} level - optional (default is 6)
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)

jz.stream.zlib.decompress({buffer, streamFn, shareMemory, chunkSize})

@param {BufferLike} buffer
@param {function(chunk: Uint8Array)} streamFn
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)

gzip

jz.gz.compress({buffer, level, chunkSize})

@param {BufferLike} buffer
@param {number} level - optional (default is 6)
@param {number} chunkSize - optional (default is 0x8000)
@return {Uint8Array}

jz.gz.decompress({buffer, chunkSize})

@param {BufferLike} buffer
@param {number} chunkSize - optional (default is 0x8000)
@return {Uint8Array}

jz.stream.gz.compress({buffer, streamFn, level, shareMemory, chunkSize, fname, fcomment})

@param {BufferLike} buffer
@param {function(chunk: Uint8Array)} streamFn
@param {number} level - optional (default is 6)
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)
@param {string} fname - optional
@param {string} fcomment - optional

jz.stream.gz.decompress({buffer, streamFn, shareMemory, chunkSize})

@param {BufferLike} buffer
@param {function(chunk: Uint8Array)} streamFn
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)

zip

jz.zip.pack({files, level, chunkSize})

@param {Array.} files
@param {number} level - optional (default is 6)
@param {number} chunkSize - optional (default is 0x8000)
@return {Promise}

var files = [
  {
    name: 'foo',
    dir: [
      // folder
      { name: 'hello.txt', buffer: 'Hello World!' }, // string
      { name: 'bar.js', buffer: buffer }, // ArrayBuffer
      { name: 'hoge.mp3', url: 'audiodata/hoge.mp3' }, // xhr
    ],
  },
];

jz.zip
  .pack({
    files: files,
    level: 5,
  })
  .then(buffer => {
    // buffer is Uint8Array
  });

// You cat set compression level to each files.
var files = [
  { name: 'mimetype', buffer: 'application/epub+zip', level: 0 }, //string
  {
    name: 'META-INF',
    dir: [
      //folder
      { name: 'container.xml', buffer: buffer, level: 0 }, //ArrayBuffer
    ],
  },
  { name: 'package.opf', url: 'package.opf', level: 6 },
  { name: 'foo.xhtml', url: 'foo.xhtml', level: 9 }, //xhr
];

jz.zip.pack({ files }).then(buffer => {
  // ...
});

jz.zip.unpack({buffer, encoding, chunkSize})

@param {BufferLike | Blob} buffer
@param {string} encoding - optional (default is "UTF-8")
@param {number} chunkSize - optional (default is 0x8000)
@return {Promise}

jz.zip
  .unpack({
    buffer: buffer,
    encoding: 'Shift_JIS', // encoding of filenames
  })
  .then(reader => {
    // reader is ZipArchiveReader. See below.
    // get file names.
    reader.getFileNames();
    reader.readFileAsText(reader.getFileNames[0]).then(text => {
      // ...
    });
  });

jz.stream.zip.pack({files, streamFn, level, shareMemory, chunkSize})

@param {Array} files
@param {function(chunk: Uint8Array)} streamFn
@param {number} level - optional (default is 6)
@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)
@return {Promise}

jz.stream.zip
  .pack({
    files: files,
    streamFn: chunk => {
      // ...
    },
  })
  .then(() => {
    // no args
  });

ZipArchiveReader

ZipArchiveReader#getFileNames()

It gets filenames in the zip archive.

@return {Array<string>}

ZipArchiveReader#readFileAsArrayBuffer(filename)

@param {string} filename
@return {Promise<ArrayBuffer>}

ZipArchiveReader#readFileAsBlob(filename)

@param {string} filename
@return {Promise<Blob>}

ZipArchiveReader#readFileAsText(filename, encoding)

@param {string} filename
@param {string} encoding
@return {Promise<string>}

ZipArchiveReader#readFileAsDataURL(filename)

@param {string} filename
@return {Promise<string>}

ZipArchiveReader#readFileAsArrayBufferSync(filename)

@param {string} filename
@return {ArrayBuffer}

ZipArchiveReader#readFileAsBlobSync(filename)

@param {string} filename
@return {Blob}

ZipArchiveReader#readFileAsTextSync(filename, encoding)

@param {string} filename
@param {string} encoding
@return {string}

ZipArchiveReader#readFileAsBinaryStringSync(filename)

@param {string} filename
@return {string}

ZipArchiveReader#readFileAsDataURLSync(filename)

@param {string} filename
@return {string}

jz.zip.ZipArchiveWriter({shareMemory, chunkSize})

Low level zip archive writer.

@param {boolean} shareMemory - optional (default is false)
@param {number} chunkSize - optional (default is 0x8000)

const writer = new jz.zip.ZipArchiveWriter({ shareMemory: true, chunkSize: 0xf000 });
writer
  .on('data', chunk => {
    // chunk is Uint8Array.
  })
  .on('end', () => {
    // ...
  })
  .write('foo/bar/baz.txt', buffer)
  .write('a.mp3', mp3Buff)
  .writeEnd();

#on(name, callback)

@param {string} name
@param {function} callback
@return {jz.zip.ZipArchiveWriter} this

#write(path, buffer, level)

Write the file. Directories are created automatically.

@param {string} path
@param {Uint8Array} buffer
@param {number} level - optional (default is 6)
@return {jz.zip.ZipArchiveWriter} this

writer.write('a/b/c/d/foo.txt', buffer, 7);

#writeDir(path)

@param {string} path
@return {jz.zip.ZipArchiveWriter} this

writer.writeDir('foo/');
// or
writer.writeDir('bar');

#writeFile(path, buffer, level)

@param {string} path
@param {Uint8Array} buffer
@param {number} level - optional (default is 6)
@return {jz.zip.ZipArchiveWriter} this

writer.writeDir('a/');
writer.writeDir('a/b/');
writer.writeDir('a/b/c/');
writer.writeFile('a/b/c/foo.txt', buffer, 7);

#writeEnd()

Write central directory headers and the end central dirctory header.

writer.writeEnd();

ES2015 Modules

You can import modules separately.

import {deflate} from "jsziptools/core";
import * as zip from "jsziptools/zip";

deflate(...);
zip.pack(...).then();

Keywords

FAQs

What is jsziptools?

Is jsziptools popular?

Is jsziptools well maintained?

Package last updated on 21 Mar 2018

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

jsziptools

jsziptools

suported browser

examples

web examples

APIs

common

BufferLike

jz.common.toBytes(buffer)

jz.common.readFileAsArrayBuffer(blob)

jz.common.readFileAsText(blob, encoding)

jz.common.readFileAsDataURL(blob)

jz.common.bytesToString(buffer)

jz.common.concatBytes(buffers)

jz.common.load(urls)

core

jz.core.deflate({buffer, level, chunkSize})

jz.core.inflate({buffer, chunkSize})

jz.core.adler32(buffer)

jz.core.crc32({buffer, crc})

jz.stream.core.deflate({buffer, streamFn, level, shareMemory, chunkSize})

jz.steram.core.inflate({buffer, streamFn, shareMemory, chunkSize})

zlib

jz.zlib.compress({buffer, level, chunkSize})

jz.zlib.decompress({buffer, chunkSize})

jz.stream.zlib.compress({buffer, streamFn, level, shareMemory, chunkSize})

jz.stream.zlib.decompress({buffer, streamFn, shareMemory, chunkSize})

gzip

jz.gz.compress({buffer, level, chunkSize})

jz.gz.decompress({buffer, chunkSize})

jz.stream.gz.compress({buffer, streamFn, level, shareMemory, chunkSize, fname, fcomment})

jz.stream.gz.decompress({buffer, streamFn, shareMemory, chunkSize})

zip

jz.zip.pack({files, level, chunkSize})

jz.zip.unpack({buffer, encoding, chunkSize})

jz.stream.zip.pack({files, streamFn, level, shareMemory, chunkSize})

ZipArchiveReader

ZipArchiveReader#getFileNames()

ZipArchiveReader#readFileAsArrayBuffer(filename)

ZipArchiveReader#readFileAsBlob(filename)

ZipArchiveReader#readFileAsText(filename, encoding)

ZipArchiveReader#readFileAsDataURL(filename)

ZipArchiveReader#readFileAsArrayBufferSync(filename)

ZipArchiveReader#readFileAsBlobSync(filename)

ZipArchiveReader#readFileAsTextSync(filename, encoding)

ZipArchiveReader#readFileAsBinaryStringSync(filename)

ZipArchiveReader#readFileAsDataURLSync(filename)

jz.zip.ZipArchiveWriter({shareMemory, chunkSize})

#on(name, callback)

#write(path, buffer, level)

#writeDir(path)

#writeFile(path, buffer, level)

#writeEnd()

ES2015 Modules

Keywords

Related posts

PyPI Now Supports iOS and Android Wheels for Mobile Python Development

Create React App Officially Deprecated Amid React 19 Compatibility Issues