@modern-js/utils 2.12.1-alpha.1 → 2.12.1-alpha.2

package/dist/types/compiled/fast-glob/out/settings.d.ts

@@ -0,0 +1,164 @@
+import { FileSystemAdapter, Pattern } from './types';
+export declare const DEFAULT_FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare type Options = {
+    /**
+     * Return the absolute path for entries.
+     *
+     * @default false
+     */
+    absolute?: boolean;
+    /**
+     * If set to `true`, then patterns without slashes will be matched against
+     * the basename of the path if it contains slashes.
+     *
+     * @default false
+     */
+    baseNameMatch?: boolean;
+    /**
+     * Enables Bash-like brace expansion.
+     *
+     * @default true
+     */
+    braceExpansion?: boolean;
+    /**
+     * Enables a case-sensitive mode for matching files.
+     *
+     * @default true
+     */
+    caseSensitiveMatch?: boolean;
+    /**
+     * Specifies the maximum number of concurrent requests from a reader to read
+     * directories.
+     *
+     * @default os.cpus().length
+     */
+    concurrency?: number;
+    /**
+     * The current working directory in which to search.
+     *
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Specifies the maximum depth of a read directory relative to the start
+     * directory.
+     *
+     * @default Infinity
+     */
+    deep?: number;
+    /**
+     * Allow patterns to match entries that begin with a period (`.`).
+     *
+     * @default false
+     */
+    dot?: boolean;
+    /**
+     * Enables Bash-like `extglob` functionality.
+     *
+     * @default true
+     */
+    extglob?: boolean;
+    /**
+     * Indicates whether to traverse descendants of symbolic link directories.
+     *
+     * @default true
+     */
+    followSymbolicLinks?: boolean;
+    /**
+     * Custom implementation of methods for working with the file system.
+     *
+     * @default fs.*
+     */
+    fs?: Partial<FileSystemAdapter>;
+    /**
+     * Enables recursively repeats a pattern containing `**`.
+     * If `false`, `**` behaves exactly like `*`.
+     *
+     * @default true
+     */
+    globstar?: boolean;
+    /**
+     * An array of glob patterns to exclude matches.
+     * This is an alternative way to use negative patterns.
+     *
+     * @default []
+     */
+    ignore?: Pattern[];
+    /**
+     * Mark the directory path with the final slash.
+     *
+     * @default false
+     */
+    markDirectories?: boolean;
+    /**
+     * Returns objects (instead of strings) describing entries.
+     *
+     * @default false
+     */
+    objectMode?: boolean;
+    /**
+     * Return only directories.
+     *
+     * @default false
+     */
+    onlyDirectories?: boolean;
+    /**
+     * Return only files.
+     *
+     * @default true
+     */
+    onlyFiles?: boolean;
+    /**
+     * Enables an object mode (`objectMode`) with an additional `stats` field.
+     *
+     * @default false
+     */
+    stats?: boolean;
+    /**
+     * By default this package suppress only `ENOENT` errors.
+     * Set to `true` to suppress any error.
+     *
+     * @default false
+     */
+    suppressErrors?: boolean;
+    /**
+     * Throw an error when symbolic link is broken if `true` or safely
+     * return `lstat` call if `false`.
+     *
+     * @default false
+     */
+    throwErrorOnBrokenSymbolicLink?: boolean;
+    /**
+     * Ensures that the returned entries are unique.
+     *
+     * @default true
+     */
+    unique?: boolean;
+};
+export default class Settings {
+    private readonly _options;
+    readonly absolute: boolean;
+    readonly baseNameMatch: boolean;
+    readonly braceExpansion: boolean;
+    readonly caseSensitiveMatch: boolean;
+    readonly concurrency: number;
+    readonly cwd: string;
+    readonly deep: number;
+    readonly dot: boolean;
+    readonly extglob: boolean;
+    readonly followSymbolicLinks: boolean;
+    readonly fs: FileSystemAdapter;
+    readonly globstar: boolean;
+    readonly ignore: Pattern[];
+    readonly markDirectories: boolean;
+    readonly objectMode: boolean;
+    readonly onlyDirectories: boolean;
+    readonly onlyFiles: boolean;
+    readonly stats: boolean;
+    readonly suppressErrors: boolean;
+    readonly throwErrorOnBrokenSymbolicLink: boolean;
+    readonly unique: boolean;
+    constructor(_options?: Options);
+    private _getValue;
+    private _getFileSystemMethods;
+}

package/dist/types/compiled/fast-glob/out/types/index.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import * as fsWalk from '../../@nodelib/fs.walk';
+export declare type ErrnoException = NodeJS.ErrnoException;
+export declare type Entry = fsWalk.Entry;
+export declare type EntryItem = string | Entry;
+export declare type Pattern = string;
+export declare type PatternRe = RegExp;
+export declare type PatternsGroup = Record<string, Pattern[]>;
+export declare type ReaderOptions = fsWalk.Options & {
+    transform(entry: Entry): EntryItem;
+    deepFilter: DeepFilterFunction;
+    entryFilter: EntryFilterFunction;
+    errorFilter: ErrorFilterFunction;
+    fs: FileSystemAdapter;
+    stats: boolean;
+};
+export declare type ErrorFilterFunction = fsWalk.ErrorFilterFunction;
+export declare type EntryFilterFunction = fsWalk.EntryFilterFunction;
+export declare type DeepFilterFunction = fsWalk.DeepFilterFunction;
+export declare type EntryTransformerFunction = (entry: Entry) => EntryItem;
+export declare type MicromatchOptions = {
+    dot?: boolean;
+    matchBase?: boolean;
+    nobrace?: boolean;
+    nocase?: boolean;
+    noext?: boolean;
+    noglobstar?: boolean;
+    posix?: boolean;
+    strictSlashes?: boolean;
+};
+export declare type FileSystemAdapter = fsWalk.FileSystemAdapter;

package/dist/types/compiled/fast-glob/package.json

@@ -0,0 +1 @@
+{"name":"fast-glob","author":{"name":"Denis Malinochkin","url":"https://mrmlnc.com"},"version":"3.2.11","license":"MIT","typings":"out/index.d.ts"}

package/dist/types/compiled/filesize/filesize.d.ts

@@ -0,0 +1,131 @@
+// Type definitions for filesize 8.0.3
+// Project: https://github.com/avoidwork/filesize.js, https://filesizejs.com
+// Definitions by: Giedrius Grabauskas <https://github.com/GiedriusGrabauskas>
+//                 Renaud Chaput <https://github.com/renchap>
+//                 Roman Nuritdinov <https://github.com/Ky6uk>
+//                 Sam Hulick <https://github.com/ffxsam>
+//                 Tomoto S. Washio <https://github.com/tomoto>
+
+declare var fileSize: Filesize.Filesize;
+export = fileSize;
+export as namespace filesize;
+
+declare namespace Filesize {
+    interface SiJedecBits {
+        b?: string;
+        Kb?: string;
+        Mb?: string;
+        Gb?: string;
+        Tb?: string;
+        Pb?: string;
+        Eb?: string;
+        Zb?: string;
+        Yb?: string;
+    }
+
+    interface SiJedecBytes {
+        B?: string;
+        KB?: string;
+        MB?: string;
+        GB?: string;
+        TB?: string;
+        PB?: string;
+        EB?: string;
+        ZB?: string;
+        YB?: string;
+    }
+
+    type SiJedec = SiJedecBits & SiJedecBytes & { [name: string]: string };
+
+    interface Options {
+        /**
+         * Number base, default is 10
+         */
+        base?: number;
+        /**
+         * Enables bit sizes, default is false
+         */
+        bits?: boolean;
+        /**
+         * Specifies the SI suffix via exponent, e.g. 2 is MB for bytes, default is -1
+         */
+        exponent?: number;
+        /**
+         * Enables full form of unit of measure, default is false
+         */
+        fullform?: boolean;
+        /**
+         * Array of full form overrides, default is []
+         */
+        fullforms?: string[];
+        /**
+         * BCP 47 language tag to specify a locale, or true to use default locale, default is ""
+         */
+        locale?: string | boolean;
+        /**
+         * ECMA-402 number format option overrides, default is "{}"
+         */
+        localeOptions?: Intl.NumberFormatOptions;
+        /**
+         * Output of function (array, exponent, object, or string), default is string
+         */
+        output?: "array" | "exponent" | "object" | "string";
+        /**
+         * Decimal place end padding, default is false
+         */
+        pad?: boolean;
+        /**
+         * Sets precision of numerical output, default is 0
+         */
+        precision?: number;
+        /**
+         * Decimal place, default is 2
+         */
+        round?: number;
+        /**
+         * Rounding method, can be round, floor, or ceil, default is round
+         */
+        roundingMethod?: "round" | "floor" | "ceil";
+        /**
+         * Decimal separator character, default is `.`
+         */
+        separator?: string;
+        /**
+         * Character between the result and suffix, default is ` `
+         */
+        spacer?: string;
+        /**
+         * Standard unit of measure, can be iec or jedec, default is iec; can be overruled by base
+         */
+        standard?: "iec" | "jedec";
+        /**
+         * Dictionary of SI/JEDEC symbols to replace for localization, defaults to english if no match is found
+         */
+        symbols?: SiJedec;
+        /**
+         *  Enables unix style human readable output, e.g ls -lh, default is false
+         */
+        unix?: boolean;
+    }
+
+    // Result type inference from the output option
+    interface ResultTypeMap {
+        array: [number, string];
+        exponent: number;
+        object: {
+            value: number,
+            symbol: string,
+            exponent: number,
+            unit: string,
+        };
+        string: string;
+    }
+    type DefaultOutput<O extends Options> = Exclude<O["output"], keyof ResultTypeMap> extends never ? never : "string"
+    type CanonicalOutput<O extends Options> = Extract<O["output"], keyof ResultTypeMap> | DefaultOutput<O>
+
+    interface Filesize {
+        (bytes: number): string;
+        <O extends Options>(bytes: number, options: O): ResultTypeMap[CanonicalOutput<O>];
+        partial: <O extends Options>(options: O) => ((bytes: number) => ResultTypeMap[CanonicalOutput<O>]);
+    }
+}

package/dist/types/compiled/filesize/index.js

@@ -0,0 +1,9 @@
+(()=>{var i={823:function(i){
+/**
+ * filesize
+ *
+ * @copyright 2022 Jason Mulligan <jason.mulligan@avoidwork.com>
+ * @license BSD-3-Clause
+ * @version 8.0.7
+ */
+(function(e,t){true?i.exports=t():0})(this,(function(){"use strict";var i=/^(b|B)$/,e={iec:{bits:["bit","Kibit","Mibit","Gibit","Tibit","Pibit","Eibit","Zibit","Yibit"],bytes:["B","KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"]},jedec:{bits:["bit","Kbit","Mbit","Gbit","Tbit","Pbit","Ebit","Zbit","Ybit"],bytes:["B","KB","MB","GB","TB","PB","EB","ZB","YB"]}},t={iec:["","kibi","mebi","gibi","tebi","pebi","exbi","zebi","yobi"],jedec:["","kilo","mega","giga","tera","peta","exa","zetta","yotta"]},r={floor:Math.floor,ceil:Math.ceil};function filesize(o){var a=arguments.length>1&&arguments[1]!==undefined?arguments[1]:{};var n=[],s=0,f,b,l,u,c,p,d,_,B,v,h,g,x,y,M,m,w,k,N,z,E;if(isNaN(o)){throw new TypeError("Invalid number")}l=a.bits===true;M=a.unix===true;g=a.pad===true;b=a.base||10;x=a.round!==void 0?a.round:M?1:2;d=a.locale!==void 0?a.locale:"";_=a.localeOptions||{};m=a.separator!==void 0?a.separator:"";w=a.spacer!==void 0?a.spacer:M?"":" ";N=a.symbols||{};k=b===2?a.standard||"iec":"jedec";h=a.output||"string";c=a.fullform===true;p=a.fullforms instanceof Array?a.fullforms:[];f=a.exponent!==void 0?a.exponent:-1;z=r[a.roundingMethod]||Math.round;v=Number(o);B=v<0;u=b>2?1e3:1024;E=isNaN(a.precision)===false?parseInt(a.precision,10):0;if(B){v=-v}if(f===-1||isNaN(f)){f=Math.floor(Math.log(v)/Math.log(u));if(f<0){f=0}}if(f>8){if(E>0){E+=8-f}f=8}if(h==="exponent"){return f}if(v===0){n[0]=0;y=n[1]=M?"":e[k][l?"bits":"bytes"][f]}else{s=v/(b===2?Math.pow(2,f*10):Math.pow(1e3,f));if(l){s=s*8;if(s>=u&&f<8){s=s/u;f++}}var j=Math.pow(10,f>0?x:0);n[0]=z(s*j)/j;if(n[0]===u&&f<8&&a.exponent===void 0){n[0]=1;f++}y=n[1]=b===10&&f===1?l?"kbit":"kB":e[k][l?"bits":"bytes"][f];if(M){n[1]=n[1].charAt(0);if(i.test(n[1])){n[0]=Math.floor(n[0]);n[1]=""}}}if(B){n[0]=-n[0]}if(E>0){n[0]=n[0].toPrecision(E)}n[1]=N[n[1]]||n[1];if(d===true){n[0]=n[0].toLocaleString()}else if(d.length>0){n[0]=n[0].toLocaleString(d,_)}else if(m.length>0){n[0]=n[0].toString().replace(".",m)}if(g&&Number.isInteger(n[0])===false&&x>0){var q=m||".",P=n[0].toString().split(q),T=P[1]||"",G=T.length,K=x-G;n[0]="".concat(P[0]).concat(q).concat(T.padEnd(G+K,"0"))}if(c){n[1]=p[f]?p[f]:t[k][f]+(l?"bit":"byte")+(n[0]===1?"":"s")}return h==="array"?n:h==="object"?{value:n[0],symbol:n[1],exponent:f,unit:y}:n.join(w)}filesize.partial=function(i){return function(e){return filesize(e,i)}};return filesize}))}};var e={};function __nccwpck_require__(t){var r=e[t];if(r!==undefined){return r.exports}var o=e[t]={exports:{}};var a=true;try{i[t].call(o.exports,o,o.exports,__nccwpck_require__);a=false}finally{if(a)delete e[t]}return o.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var t=__nccwpck_require__(823);module.exports=t})();

package/dist/types/compiled/filesize/license

@@ -0,0 +1,28 @@
+Copyright (c) 2022, Jason Mulligan
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of filesize nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/dist/types/compiled/filesize/package.json

@@ -0,0 +1 @@
+{"name":"filesize","author":"Jason Mulligan <jason.mulligan@avoidwork.com>","version":"8.0.7","license":"BSD-3-Clause","types":"filesize.d.ts"}