jszip

property external

external: {
    Promise: PromiseConstructorLike;
};

property files

files: { [key: string]: JSZip.JSZipObject };

property prototype

prototype: JSZip;

property support

support: JSZipSupport;

property version

version: string;

method file

file: {
    (path: string): JSZip.JSZipObject | null;
    (path: RegExp): JSZip.JSZipObject[];
    <T extends keyof InputByType>(
        path: string,
        data: InputByType[T] | Promise<InputByType[T]>,
        options?: JSZip.JSZipFileOptions
    ): this;
    <T extends keyof InputByType>(
        path: string,
        data: null,
        options?: JSZip.JSZipFileOptions & { dir: true }
    ): this;
};

• Get a file from the archive

  Parameter Path

  relative path to file File matching path, null if no file found

• Get files matching a RegExp from archive

  Parameter path

  RegExp to match Return all matching files or an empty array

• Add a file to the archive

  Parameter path

  Relative path to file

  Parameter data

  Content of the file

  Parameter options

  Optional information about the file JSZip object

method filter

filter: (
    predicate: (relativePath: string, file: JSZip.JSZipObject) => boolean
) => JSZip.JSZipObject[];

• Get all files which match the given filter function

  Parameter predicate

  Filter function Array of matched elements

method folder

folder: { (name: string): JSZip | null; (name: RegExp): JSZip.JSZipObject[] };

• Returns an new JSZip instance with the given folder as root

  Parameter name

  Name of the folder New JSZip object with the given folder as root or null

• Returns new JSZip instances with the matching folders as root

  Parameter name

  RegExp to match New array of JSZipFile objects which match the RegExp

method forEach

forEach: (
    callback: (relativePath: string, file: JSZip.JSZipObject) => void
) => void;

• Call a callback function for each entry at this folder level.

  Parameter callback

  function

method generateAsync

generateAsync: <T extends keyof OutputByType>(
    options?: JSZip.JSZipGeneratorOptions<T>,
    onUpdate?: JSZip.OnUpdateCallback
) => Promise<OutputByType[T]>;

• Generates a new archive asynchronously

  Parameter options

  Optional options for the generator

  Parameter onUpdate

  The optional function called on each internal update with the metadata. The serialized archive

method generateInternalStream

generateInternalStream: <T extends keyof OutputByType>(
    options?: JSZip.JSZipGeneratorOptions<T>
) => JSZip.JSZipStreamHelper<OutputByType[T]>;

• Generates the complete zip file with the internal stream implementation

  Parameter options

  Optional options for the generator a StreamHelper

method generateNodeStream

generateNodeStream: (
    options?: JSZip.JSZipGeneratorOptions<'nodebuffer'>,
    onUpdate?: JSZip.OnUpdateCallback
) => NodeJS.ReadableStream;

• Generates a new archive asynchronously

  Parameter options

  Optional options for the generator

  Parameter onUpdate

  The optional function called on each internal update with the metadata. A Node.js ReadableStream

method loadAsync

loadAsync: (
    data: InputFileFormat,
    options?: JSZip.JSZipLoadOptions
) => Promise<JSZip>;

• Deserialize zip file asynchronously

  Parameter data

  Serialized zip file

  Parameter options

  Options for deserializing Returns promise

method remove

remove: (path: string) => JSZip;

• Removes the file or folder from the archive

  Parameter path

  Relative path of file or folder Returns the JSZip instance

construct signature

new (): this;

• Create JSZip instance

call signature

(): JSZip;

property base64

base64?: boolean;

• Set to true if the data is base64 encoded. For example image data from a <canvas> element. Plain text and HTML do not need this option.

property binary

binary?: boolean;

• Set to true if the data should be treated as raw content, false if this is a text. If base64 is used, this defaults to true, if the data is not a string, this will be set to true.

property comment

comment?: string;

property compression

compression?: Compression;

• Sets per file compression. The compressionOptions parameter depends on the compression type.

property compressionOptions

compressionOptions?: null | CompressionOptions;

• Sets per file compression level for DEFLATE compression.

property createFolders

createFolders?: boolean;

• Set to true if folders in the file path should be automatically created, otherwise there will only be virtual folders that represent the path to the file.

property date

date?: Date;

• The last modification date, defaults to the current date.

property dir

dir?: boolean;

• Set to true if this is a directory and content should be ignored.

property dosPermissions

dosPermissions?: number | null;

• 6 bits number. The DOS permissions of the file, if any.

property optimizedBinaryString

optimizedBinaryString?: boolean;

• Set to true if (and only if) the input is a "binary string" and has already been prepared with a 0xFF mask.

property unixPermissions

unixPermissions?: number | string | null;

• 16 bits number. The UNIX permissions of the file, if any. Also accepts a string representing the octal value: "644", "755", etc.

property comment

comment?: string;

property compression

compression?: Compression;

• Sets compression option for all entries that have not specified their own compression option

property compressionOptions

compressionOptions?: null | CompressionOptions;

• Sets compression level for DEFLATE compression.

property mimeType

mimeType?: string;

• mime-type for the generated file. Useful when you need to generate a file with a different extension, ie: “.ods”. 'application/zip'

property platform

platform?: 'DOS' | 'UNIX';

• DOS (default) or UNIX

property streamFiles

streamFiles?: boolean;

• Stream the files and create file descriptors

property type

type?: T;

method encodeFileName

encodeFileName: (filename: string) => string;

property base64

base64?: boolean;

property checkCRC32

checkCRC32?: boolean;

property createFolders

createFolders?: boolean;

property decodeFileName

decodeFileName?: (bytes: string[] | Uint8Array | Buffer) => string;

property optimizedBinaryString

optimizedBinaryString?: boolean;

property currentFile

currentFile: string | null;

property percent

percent: number;

property comment

comment: string;

property date

date: Date;

property dir

dir: boolean;

property dosPermissions

dosPermissions: number | null;

• The UNIX permissions of the file, if any.

property name

name: string;

property options

options: JSZipObjectOptions;

property unixPermissions

unixPermissions: number | string | null;

• The UNIX permissions of the file, if any.

property unsafeOriginalName

unsafeOriginalName?: string;

• Present for files loadded with loadAsync. May contain ".." path components that could result in a zip-slip attack. See https://snyk.io/research/zip-slip-vulnerability

method async

async: <T extends keyof OutputByType>(
    type: T,
    onUpdate?: OnUpdateCallback
) => Promise<OutputByType[T]>;

• Prepare the content in the asked type.

  Parameter type

  the type of the result.

  Parameter onUpdate

  a function to call on each internal update. Promise the promise of the result.

method nodeStream

nodeStream: (
    type?: 'nodebuffer',
    onUpdate?: OnUpdateCallback
) => NodeJS.ReadableStream;

property compression

compression: Compression;

method accumulate

accumulate: (updateCallback?: (metadata: JSZipMetadata) => void) => Promise<T>;

• Read the whole stream and call a callback with the complete content

  Parameter updateCallback

  The function called every time the stream updates A Promise of the full content

method on

on: {
    (event: 'data', callback: DataEventCallback<T>): this;
    (event: 'end', callback: EndEventCallback): this;
    (event: 'error', callback: ErrorEventCallback): this;
};

• Register a listener on an event

method pause

pause: () => this;

• Pause the stream if the stream is running. Once paused, the stream stops sending data events

  The current StreamHelper object, for chaining

method resume

resume: () => this;

• Resume the stream if the stream is paused. Once resumed, the stream starts sending data events again

  The current StreamHelper object, for chaining