@ffflorian/jszip-cli 3.5.4 → 3.5.6

package/dist/esm/BuildService.js

@@ -1,201 +0,0 @@
-import * as fs from 'fs-extra';
-import JSZip from 'jszip';
-import logdown from 'logdown';
-import path from 'path';
-import progress from 'progress';
-import { FileService } from './FileService.js';
-import { globSync } from 'glob';
-export class BuildService {
-    constructor(options) {
-        this.fileService = new FileService(options);
-        this.jszip = new JSZip();
-        this.options = options;
-        this.logger = logdown('jszip-cli/BuildService', {
-            logger: console,
-            markdown: false,
-        });
-        this.logger.state = { isEnabled: options.verbose };
-        this.entries = [];
-        this.ignoreEntries = this.options.ignoreEntries.map(entry => entry instanceof RegExp ? entry : new RegExp(entry.replace(/\*/g, '.*')));
-        this.outputFile = this.options.outputEntry ? path.resolve(this.options.outputEntry) : null;
-        this.progressBar = new progress('Compressing [:bar] :percent :elapseds', {
-            complete: '=',
-            incomplete: ' ',
-            total: 100,
-            width: 20,
-        });
-        this.compressedFilesCount = 0;
-    }
-    add(rawEntries) {
-        this.logger.info(`Adding ${rawEntries.length} entr${rawEntries.length === 1 ? 'y' : 'ies'} to ZIP file.`);
-        const normalizedEntries = this.normalizePaths(rawEntries);
-        this.entries = globSync(normalizedEntries).map(rawEntry => {
-            const resolvedPath = path.resolve(rawEntry);
-            const baseName = path.basename(rawEntry);
-            return {
-                resolvedPath,
-                zipPath: baseName,
-            };
-        });
-        return this;
-    }
-    async save() {
-        await this.checkOutput();
-        await Promise.all(this.entries.map(entry => this.checkEntry(entry)));
-        const data = await this.getBuffer();
-        if (this.outputFile) {
-            if (!this.outputFile.match(/\.\w+$/)) {
-                this.outputFile = path.join(this.outputFile, 'data.zip');
-            }
-            this.logger.info(`Saving finished zip file to "${this.outputFile}" ...`);
-            await this.fileService.writeFile(data, this.outputFile);
-        }
-        else {
-            process.stdout.write(data);
-        }
-        return this;
-    }
-    /**
-     * Note: glob patterns should always use / as a path separator, even on Windows systems,
-     * as \ is used to escape glob characters.
-     * https://github.com/isaacs/node-glob
-     */
-    normalizePaths(rawEntries) {
-        return rawEntries.map(entry => entry.replace(/\\/g, '/'));
-    }
-    async addFile(entry, isLink = false) {
-        const { resolvedPath, zipPath } = entry;
-        let fileStat;
-        let fileData;
-        try {
-            fileData = isLink ? await fs.readlink(resolvedPath) : await fs.readFile(resolvedPath);
-            fileStat = await fs.lstat(resolvedPath);
-        }
-        catch (error) {
-            if (!this.options.quiet) {
-                this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
-            }
-            this.logger.info(error);
-            return;
-        }
-        this.logger.info(`Adding file "${resolvedPath}" to ZIP file ...`);
-        this.jszip.file(zipPath, fileData, {
-            createFolders: true,
-            date: fileStat.mtime,
-            // See https://github.com/Stuk/jszip/issues/550
-            // dosPermissions: fileStat.mode,
-            unixPermissions: fileStat.mode,
-        });
-        this.compressedFilesCount++;
-    }
-    async addLink(entry) {
-        const { resolvedPath, zipPath } = entry;
-        if (this.options.dereferenceLinks) {
-            let realPath;
-            try {
-                realPath = await fs.realpath(resolvedPath);
-            }
-            catch (error) {
-                if (!this.options.quiet) {
-                    this.logger.info(`Can't read link "${entry.resolvedPath}". Ignoring.`);
-                }
-                this.logger.info(error);
-                return;
-            }
-            this.logger.info(`Found real path "${realPath} for symbolic link".`);
-            await this.checkEntry({
-                resolvedPath: realPath,
-                zipPath,
-            });
-        }
-        else {
-            await this.addFile(entry, true);
-        }
-    }
-    async checkEntry(entry) {
-        let fileStat;
-        try {
-            fileStat = await fs.lstat(entry.resolvedPath);
-        }
-        catch (error) {
-            if (!this.options.quiet) {
-                this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
-            }
-            this.logger.info(error);
-            return;
-        }
-        const ignoreEntries = this.ignoreEntries.filter(ignoreEntry => Boolean(entry.resolvedPath.match(ignoreEntry)));
-        if (ignoreEntries.length) {
-            this.logger.info(`Found ${entry.resolvedPath}. Not adding since it's on the ignore list:`, ignoreEntries.map(entry => String(entry)));
-            return;
-        }
-        if (fileStat.isDirectory()) {
-            this.logger.info(`Found directory "${entry.resolvedPath}".`);
-            await this.walkDir(entry);
-        }
-        else if (fileStat.isFile()) {
-            this.logger.info(`Found file "${entry.resolvedPath}".`);
-            this.logger.info(`Found file "${entry.resolvedPath}".`);
-            await this.addFile(entry);
-        }
-        else if (fileStat.isSymbolicLink()) {
-            this.logger.info(`Found symbolic link "${entry.resolvedPath}".`);
-            await this.addLink(entry);
-        }
-        else {
-            this.logger.info('Unknown file type.', { fileStat });
-            if (!this.options.quiet) {
-                this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
-            }
-        }
-    }
-    async checkOutput() {
-        if (this.outputFile) {
-            if (this.outputFile.match(/\.\w+$/)) {
-                const dirExists = await this.fileService.dirExists(path.dirname(this.outputFile));
-                if (!dirExists) {
-                    throw new Error(`Directory "${path.dirname(this.outputFile)}" doesn't exist or is not writable.`);
-                }
-                const fileIsWritable = await this.fileService.fileIsWritable(this.outputFile);
-                if (!fileIsWritable) {
-                    throw new Error(`File "${this.outputFile}" already exists.`);
-                }
-            }
-            else {
-                const dirExists = await this.fileService.dirExists(this.outputFile);
-                if (!dirExists) {
-                    throw new Error(`Directory "${this.outputFile}" doesn't exist or is not writable.`);
-                }
-            }
-        }
-    }
-    getBuffer() {
-        const compressionType = this.options.compressionLevel === 0 ? 'STORE' : 'DEFLATE';
-        let lastPercent = 0;
-        return this.jszip.generateAsync({
-            compression: compressionType,
-            compressionOptions: {
-                level: this.options.compressionLevel,
-            },
-            type: 'nodebuffer',
-        }, ({ percent }) => {
-            const diff = Math.floor(percent) - Math.floor(lastPercent);
-            if (diff && !this.options.quiet) {
-                this.progressBar.tick(diff);
-                lastPercent = Math.floor(percent);
-            }
-        });
-    }
-    async walkDir(entry) {
-        this.logger.info(`Walking directory ${entry.resolvedPath} ...`);
-        const dirEntries = await fs.readdir(entry.resolvedPath);
-        for (const dirEntry of dirEntries) {
-            const newZipPath = entry.zipPath === '.' ? dirEntry : `${entry.zipPath}/${dirEntry}`;
-            const newResolvedPath = path.join(entry.resolvedPath, dirEntry);
-            await this.checkEntry({
-                resolvedPath: newResolvedPath,
-                zipPath: newZipPath,
-            });
-        }
-    }
-}

package/dist/esm/ExtractService.js

@@ -1,84 +0,0 @@
-import fs from 'fs-extra';
-import JSZip from 'jszip';
-import logdown from 'logdown';
-import os from 'os';
-import path from 'path';
-import progress from 'progress';
-export class ExtractService {
-    constructor(options) {
-        this.options = options;
-        this.logger = logdown('jszip-cli/ExtractService', {
-            logger: console,
-            markdown: false,
-        });
-        this.logger.state.isEnabled = this.options.verbose;
-        this.outputDir = this.options.outputEntry ? path.resolve(this.options.outputEntry) : null;
-        this.progressBar = new progress('Extracting [:bar] :percent :elapseds', {
-            complete: '=',
-            incomplete: ' ',
-            total: 100,
-            width: 20,
-        });
-        this.extractedFilesCount = 0;
-    }
-    async extract(rawEntries) {
-        const isWin32 = os.platform() === 'win32';
-        for (const entry of rawEntries) {
-            const jszip = new JSZip();
-            if (this.outputDir) {
-                await fs.ensureDir(this.outputDir);
-            }
-            const resolvedPath = path.resolve(entry);
-            const data = await fs.readFile(resolvedPath);
-            const entries = [];
-            await jszip.loadAsync(data, { createFolders: true });
-            if (!this.outputDir) {
-                await this.printStream(jszip.generateNodeStream());
-                return this;
-            }
-            jszip.forEach((filePath, entry) => {
-                if (filePath.includes('..')) {
-                    this.logger.info(`Skipping bad path "${filePath}"`);
-                }
-                else {
-                    entries.push([filePath, entry]);
-                }
-            });
-            let lastPercent = 0;
-            await Promise.all(entries.map(async ([filePath, entry], index) => {
-                const resolvedFilePath = path.join(this.outputDir, filePath);
-                if (entry.dir) {
-                    await fs.ensureDir(resolvedFilePath);
-                }
-                else {
-                    const data = await entry.async('nodebuffer');
-                    await fs.writeFile(resolvedFilePath, data, {
-                        encoding: 'utf-8',
-                    });
-                    this.extractedFilesCount++;
-                    const diff = Math.floor(index / entries.length) - Math.floor(lastPercent);
-                    if (diff && !this.options.quiet) {
-                        this.progressBar.tick(diff);
-                        lastPercent = Math.floor(index / entries.length);
-                    }
-                }
-                if (isWin32) {
-                    if (entry.dosPermissions) {
-                        await fs.chmod(resolvedFilePath, entry.dosPermissions);
-                    }
-                }
-                else if (entry.unixPermissions) {
-                    await fs.chmod(resolvedFilePath, entry.unixPermissions);
-                }
-            }));
-        }
-        return this;
-    }
-    printStream(fileStream) {
-        return new Promise((resolve, reject) => {
-            const stream = fileStream.pipe(process.stdout);
-            stream.on('finish', resolve);
-            stream.on('error', reject);
-        });
-    }
-}

package/dist/esm/FileService.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { TerminalOptions } from './interfaces.js';
-export declare class FileService {
-    private readonly logger;
-    private readonly options;
-    constructor(options: Required<TerminalOptions>);
-    dirExists(dirPath: string): Promise<boolean>;
-    fileIsReadable(filePath: string): Promise<boolean>;
-    fileIsWritable(filePath: string): Promise<boolean>;
-    writeFile(data: Buffer, filePath: string): Promise<FileService>;
-}

package/dist/esm/FileService.js

@@ -1,70 +0,0 @@
-import fs from 'fs-extra';
-import logdown from 'logdown';
-import path from 'path';
-export class FileService {
-    constructor(options) {
-        this.options = options;
-        this.logger = logdown('jszip-cli/FileService', {
-            logger: console,
-            markdown: false,
-        });
-        this.logger.state.isEnabled = this.options.verbose;
-    }
-    async dirExists(dirPath) {
-        try {
-            await fs.access(dirPath, fs.constants.F_OK);
-            try {
-                await fs.access(dirPath, fs.constants.W_OK);
-                return true;
-            }
-            catch (error) {
-                this.logger.info(`Directory "${dirPath}" exists but is not writable.`);
-                return false;
-            }
-        }
-        catch (error) {
-            this.logger.info(`Directory "${dirPath}" doesn't exist.`, this.options.force ? 'Creating.' : 'Not creating.');
-            if (this.options.force) {
-                await fs.ensureDir(dirPath);
-                return true;
-            }
-            return false;
-        }
-    }
-    async fileIsReadable(filePath) {
-        const dirExists = await this.dirExists(path.dirname(filePath));
-        if (dirExists) {
-            try {
-                await fs.access(filePath, fs.constants.F_OK | fs.constants.R_OK);
-                return true;
-            }
-            catch (error) {
-                return false;
-            }
-        }
-        return false;
-    }
-    async fileIsWritable(filePath) {
-        const dirName = path.dirname(filePath);
-        const dirExists = await this.dirExists(dirName);
-        if (dirExists) {
-            try {
-                await fs.access(filePath, fs.constants.F_OK | fs.constants.R_OK);
-                this.logger.info(`File "${filePath}" already exists.`, this.options.force ? 'Forcing overwrite.' : 'Not overwriting.');
-                return this.options.force;
-            }
-            catch (error) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async writeFile(data, filePath) {
-        const fileIsWritable = await this.fileIsWritable(filePath);
-        if (fileIsWritable) {
-            await fs.writeFile(filePath, data);
-            return this;
-        }
-        throw new Error(`File "${this.options.outputEntry}" already exists.`);
-    }
-}

package/dist/esm/JSZipCLI.d.ts

@@ -1,32 +0,0 @@
-import { BuildService } from './BuildService.js';
-import { ExtractService } from './ExtractService.js';
-import type { TerminalOptions } from './interfaces.js';
-export declare class JSZipCLI {
-    private readonly buildService;
-    private readonly configExplorer;
-    private readonly configFile?;
-    private readonly extractService;
-    private readonly logger;
-    private options;
-    private readonly terminalOptions?;
-    constructor(options?: TerminalOptions);
-    /**
-     * Add files and directories to the ZIP file.
-     * @param rawEntries The entries (files, directories) to add.
-     * If not specified, entries from configuration file are used.
-     */
-    add(rawEntries?: string[]): BuildService;
-    /**
-     * Add files and directories to the ZIP file.
-     * @param rawEntries The entries (files, directories) to extract.
-     * If not specified, entries from configuration file are used.
-     */
-    extract(rawEntries?: string[]): Promise<ExtractService>;
-    /**
-     * Run in file mode - reads entries and settings from configuration file.
-     * Options from the constructor still take precedence.
-     */
-    fileMode(): Promise<JSZipCLI>;
-    save(): Promise<BuildService>;
-    private checkConfigFile;
-}

package/dist/esm/JSZipCLI.js

@@ -1,121 +0,0 @@
-import { cosmiconfigSync } from 'cosmiconfig';
-import logdown from 'logdown';
-import { BuildService } from './BuildService.js';
-import { ExtractService } from './ExtractService.js';
-const defaultOptions = {
-    compressionLevel: 5,
-    configFile: true,
-    dereferenceLinks: false,
-    force: false,
-    ignoreEntries: [],
-    outputEntry: null,
-    quiet: false,
-    verbose: false,
-};
-export class JSZipCLI {
-    constructor(options) {
-        this.terminalOptions = options;
-        this.logger = logdown('jszip-cli/index', {
-            logger: console,
-            markdown: false,
-        });
-        this.configExplorer = cosmiconfigSync('jszip');
-        this.options = Object.assign(Object.assign({}, defaultOptions), this.terminalOptions);
-        this.logger.state.isEnabled = this.options.verbose;
-        this.logger.info('Merged options', this.options);
-        this.checkConfigFile();
-        this.logger.info('Loaded options', this.options);
-        this.buildService = new BuildService(this.options);
-        this.extractService = new ExtractService(this.options);
-    }
-    /**
-     * Add files and directories to the ZIP file.
-     * @param rawEntries The entries (files, directories) to add.
-     * If not specified, entries from configuration file are used.
-     */
-    add(rawEntries) {
-        if (!rawEntries || !rawEntries.length) {
-            if (this.options.entries) {
-                rawEntries = this.options.entries;
-            }
-            else {
-                throw new Error('No entries to add.');
-            }
-        }
-        return this.buildService.add(rawEntries);
-    }
-    /**
-     * Add files and directories to the ZIP file.
-     * @param rawEntries The entries (files, directories) to extract.
-     * If not specified, entries from configuration file are used.
-     */
-    extract(rawEntries) {
-        if (!rawEntries || !rawEntries.length) {
-            if (this.options.entries) {
-                rawEntries = this.options.entries;
-            }
-            else {
-                throw new Error('No entries to extract.');
-            }
-        }
-        return this.extractService.extract(rawEntries);
-    }
-    /**
-     * Run in file mode - reads entries and settings from configuration file.
-     * Options from the constructor still take precedence.
-     */
-    async fileMode() {
-        if (!this.options.mode && !this.configFile) {
-            throw new Error('No configuration file and no mode specified.');
-        }
-        if (this.options.mode === 'add') {
-            const { outputFile, compressedFilesCount } = await this.add().save();
-            if (this.options.outputEntry && !this.options.quiet) {
-                console.info(`Done compressing ${compressedFilesCount} files to "${outputFile}".`);
-            }
-            return this;
-        }
-        else if (this.options.mode === 'extract') {
-            const { outputDir, extractedFilesCount } = await this.extract();
-            if (this.options.outputEntry && !this.options.quiet) {
-                console.info(`Done extracting ${extractedFilesCount} files to "${outputDir}".`);
-            }
-            return this;
-        }
-        throw new Error('No or invalid mode in configuration file defined.');
-    }
-    save() {
-        return this.buildService.save();
-    }
-    checkConfigFile() {
-        if (!this.options.configFile) {
-            this.logger.info('Not using any configuration file.');
-            return;
-        }
-        let configResult = null;
-        if (typeof this.options.configFile === 'string') {
-            try {
-                configResult = this.configExplorer.load(this.options.configFile);
-            }
-            catch (error) {
-                throw new Error(`Can't read configuration file: ${error.message}`);
-            }
-        }
-        else if (this.options.configFile === true) {
-            try {
-                configResult = this.configExplorer.search();
-            }
-            catch (error) {
-                this.logger.error(error);
-            }
-        }
-        if (!configResult || configResult.isEmpty) {
-            this.logger.info('Not using any configuration file.');
-            return;
-        }
-        const configFileData = configResult.config;
-        this.logger.info(`Using configuration file ${configResult.filepath}`);
-        this.options = Object.assign(Object.assign(Object.assign({}, defaultOptions), configFileData), this.terminalOptions);
-        this.logger.state.isEnabled = this.options.verbose;
-    }
-}

package/dist/esm/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/esm/cli.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-import { program as commander } from 'commander';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { JSZipCLI } from './JSZipCLI.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const defaultPackageJsonPath = path.join(__dirname, '../../package.json');
-const packageJsonPath = fs.existsSync(defaultPackageJsonPath)
-    ? defaultPackageJsonPath
-    : path.join(__dirname, '../package.json');
-const { description, name, version } = fs.readJSONSync(packageJsonPath);
-commander
-    .name(name.replace(/^@[^/]+\//, ''))
-    .description(description)
-    .option('--noconfig', "don't look for a configuration file")
-    .option('-c, --config <path>', 'use a configuration file (default: .jsziprc.json)')
-    .option('-d, --dereference', 'dereference (follow) links', false)
-    .option('-f, --force', 'force overwriting files and directories when extracting', false)
-    .option('-i, --ignore <entry>', 'ignore a file or directory')
-    .option('-l, --level <number>', 'set the compression level', '5')
-    .option('-o, --output <dir>', 'set the output file or directory (default: stdout)')
-    .option('-q, --quiet', "don't log anything", false)
-    .option('-V, --verbose', 'enable verbose logging', false)
-    .version(version, '-v, --version')
-    .on('command:*', args => {
-    console.error(`\n  error: invalid command \`${args[0]}'\n`);
-    process.exit(1);
-});
-commander
-    .command('add')
-    .alias('a')
-    .description('add files and directories to a new ZIP archive')
-    .option('--noconfig', "don't look for a configuration file")
-    .option('-c, --config <path>', 'use a configuration file')
-    .option('-d, --dereference', 'dereference (follow) symlinks', false)
-    .option('-f, --force', 'force overwriting files and directories when extracting', false)
-    .option('-i, --ignore <entry>', 'ignore a file or directory')
-    .option('-l, --level <number>', 'set the compression level', '5')
-    .option('-o, --output <dir>', 'set the output file or directory (default: stdout)')
-    .option('-q, --quiet', "don't log anything excluding errors", false)
-    .option('-V, --verbose', 'enable verbose logging', false)
-    .arguments('[entries...]')
-    .action(async (entries) => {
-    const options = commander.opts();
-    try {
-        const jszip = new JSZipCLI(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (options.level && { compressionLevel: Number(options.level) })), ((options.config && { configFile: options.config }) || (options.noconfig && { configFile: false }))), (options.dereference && { dereferenceLinks: options.dereference })), (options.force && { force: options.force })), (options.ignore && { ignoreEntries: [options.ignore] })), (options.output && { outputEntry: options.output })), (options.quiet && { quiet: options.quiet })), (options.verbose && { verbose: options.verbose })));
-        jszip.add(entries);
-        const { outputFile, compressedFilesCount } = await jszip.save();
-        if (options.output && !options.quiet) {
-            console.info(`Done compressing ${compressedFilesCount} files to "${outputFile}".`);
-        }
-    }
-    catch (error) {
-        console.error('Error:', error.message);
-        process.exit(1);
-    }
-});
-commander
-    .command('extract')
-    .alias('e')
-    .description('extract files and directories from ZIP archive(s)')
-    .option('--noconfig', "don't look for a configuration file", false)
-    .option('-c, --config <path>', 'use a configuration file (default: .jsziprc.json)')
-    .option('-o, --output <dir>', 'set the output file or directory (default: stdout)')
-    .option('-i, --ignore <entry>', 'ignore a file or directory')
-    .option('-f, --force', 'force overwriting files and directories', false)
-    .option('-V, --verbose', 'enable verbose logging', false)
-    .option('-q, --quiet', "don't log anything excluding errors", false)
-    .arguments('<archives...>')
-    .action(async (archives) => {
-    const options = commander.opts();
-    try {
-        const { outputDir, extractedFilesCount } = await new JSZipCLI(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, ((options.config && { configFile: options.config }) || (options.noconfig && { configFile: false }))), (options.force && { force: options.force })), (options.ignore && { ignoreEntries: [options.ignore] })), (options.output && { outputEntry: options.output })), (options.quiet && { quiet: options.quiet })), (options.verbose && { verbose: options.verbose }))).extract(archives);
-        if (options.output && !options.quiet) {
-            console.info(`Done extracting ${extractedFilesCount} files to "${outputDir}".`);
-        }
-    }
-    catch (error) {
-        console.error('Error:', error.message);
-        process.exit(1);
-    }
-});
-commander
-    .command('fileMode', { hidden: true, isDefault: true })
-    .option('--noconfig', "don't look for a configuration file", false)
-    .option('-c, --config <path>', 'use a configuration file (default: .jsziprc.json)')
-    .option('-o, --output <dir>', 'set the output file or directory (default: stdout)')
-    .option('-i, --ignore <entry>', 'ignore a file or directory')
-    .option('-f, --force', 'force overwriting files and directories', false)
-    .option('-V, --verbose', 'enable verbose logging', false)
-    .option('-q, --quiet', "don't log anything excluding errors", false)
-    .action(async () => {
-    const options = commander.opts();
-    try {
-        if (options.noconfig) {
-            commander.outputHelp();
-        }
-        await new JSZipCLI(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (options.config && { configFile: options.config })), (options.force && { force: options.force })), (options.ignore && { ignoreEntries: [options.ignore] })), (options.output && { outputEntry: options.output })), (options.quiet && { quiet: options.quiet })), (options.verbose && { verbose: options.verbose }))).fileMode();
-    }
-    catch (error) {
-        if (error.message.includes('ENOENT')) {
-            console.error('Error:', `Configuration file "${options.config}" not found and no mode specified.`);
-        }
-        else {
-            console.error('Error:', error.message);
-        }
-        process.exit(1);
-    }
-});
-commander.parse(process.argv);

package/dist/esm/index.d.ts

@@ -1,2 +0,0 @@
-export * from './JSZipCLI.js';
-export * from './interfaces.js';

package/dist/esm/index.js

@@ -1,2 +0,0 @@
-export * from './JSZipCLI.js';
-export * from './interfaces.js';

package/dist/esm/interfaces.d.ts

@@ -1,28 +0,0 @@
-export interface TerminalOptions {
-    /** The compression level to use (0 = save only, 9 = best compression) (default: 5). */
-    compressionLevel?: number;
-    /** Use a configuration file (default: .jsziprc.json). */
-    configFile?: string | boolean;
-    /** Whether to dereference (follow) symlinks (default: false). */
-    dereferenceLinks?: boolean;
-    /** Force overwriting files and directories when extracting (default: false). */
-    force?: boolean;
-    /** Ignore entries (e.g. `*.js.map`). */
-    ignoreEntries?: Array<string | RegExp>;
-    /** Set the output directory (default: stdout). */
-    outputEntry?: string | null;
-    /** Don't log anything excluding errors (default: false). */
-    quiet?: boolean;
-    /** Enable verbose logging (default: false). */
-    verbose?: boolean;
-}
-export interface ConfigFileOptions extends TerminalOptions {
-    /** Which files or directories to add. */
-    entries: string[];
-    /** Add or extract files. */
-    mode: 'add' | 'extract';
-}
-export interface Entry {
-    resolvedPath: string;
-    zipPath: string;
-}

package/dist/esm/interfaces.js

@@ -1 +0,0 @@
-export {};