@poppinss/utils 5.0.0 → 6.0.0-1

package/build/src/object_builder.d.ts

@@ -0,0 +1,10 @@
+export declare class ObjectBuilder {
+    #private;
+    value: Record<any, any>;
+    constructor(initialValue?: Record<any, any>, ignoreNull?: boolean);
+    add(key: string, value: any): this;
+    remove(key: string): this;
+    has(key: string): boolean;
+    get<T extends any>(key: string): T;
+    toObject(): Record<any, any>;
+}

package/build/src/object_builder.js

@@ -0,0 +1,31 @@
+export class ObjectBuilder {
+    #ignoreNull;
+    value = {};
+    constructor(initialValue, ignoreNull) {
+        this.value = initialValue !== undefined ? initialValue : {};
+        this.#ignoreNull = ignoreNull === true ? true : false;
+    }
+    add(key, value) {
+        if (value === undefined) {
+            return this;
+        }
+        if (this.#ignoreNull === true && value === null) {
+            return this;
+        }
+        this.value[key] = value;
+        return this;
+    }
+    remove(key) {
+        delete this.value[key];
+        return this;
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    get(key) {
+        return this.value[key];
+    }
+    toObject() {
+        return this.value;
+    }
+}

package/build/src/{Helpers/safeEqual.d.ts → safe_equal.d.ts}

@@ -3,8 +3,5 @@ declare type BufferSafeValue = ArrayBuffer | SharedArrayBuffer | number[] | stri
 } | {
     [Symbol.toPrimitive](hint: 'string'): string;
 };
-/**
- * Generates a random string for a given size
- */
-export declare function safeEqual<T extends BufferSafeValue>(value: T, comparisonValue: T): boolean;
+export declare function safeEqual<T extends BufferSafeValue, U extends BufferSafeValue>(trustedValue: T, userInput: U): boolean;
 export {};

package/build/src/safe_equal.js

@@ -0,0 +1,14 @@
+import { Buffer } from 'node:buffer';
+import { timingSafeEqual } from 'node:crypto';
+export function safeEqual(trustedValue, userInput) {
+    if (typeof trustedValue === 'string' && typeof userInput === 'string') {
+        const trustedLength = Buffer.byteLength(trustedValue);
+        const trustedValueBuffer = Buffer.alloc(trustedLength, 0, 'utf-8');
+        trustedValueBuffer.write(trustedValue);
+        const userValueBuffer = Buffer.alloc(trustedLength, 0, 'utf-8');
+        userValueBuffer.write(userInput);
+        return (timingSafeEqual(trustedValueBuffer, userValueBuffer) &&
+            trustedLength === Buffer.byteLength(userInput));
+    }
+    return timingSafeEqual(Buffer.from(trustedValue), Buffer.from(userInput));
+}

package/build/src/slash.d.ts

@@ -1,5 +1 @@
-/**
- * Convert windows path to unix.
- * Copied from https://github.com/sindresorhus/slash as the package is ESM only
- */
-export declare function slash(filePath: string): string;
+export { default as slash } from 'slash';

package/build/src/slash.js

@@ -1,24 +1 @@
-"use strict";
-/*
- * @poppinss/utils
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.slash = void 0;
-/**
- * Convert windows path to unix.
- * Copied from https://github.com/sindresorhus/slash as the package is ESM only
- */
-function slash(filePath) {
-    const isExtendedLengthPath = /^\\\\\?\\/.test(filePath);
-    const hasNonAscii = /[^\u0000-\u0080]+/.test(filePath); // eslint-disable-line no-control-regex
-    if (isExtendedLengthPath || hasNonAscii) {
-        return filePath;
-    }
-    return filePath.replace(/\\/g, '/');
-}
-exports.slash = slash;
+export { default as slash } from 'slash';

package/build/src/string/bytes.d.ts

@@ -0,0 +1,6 @@
+import { BytesOptions } from 'bytes';
+declare const _default: {
+    format(valueInBytes: number, options?: BytesOptions): string;
+    parse(unit: string | number): number;
+};
+export default _default;

package/build/src/string/bytes.js

@@ -0,0 +1,12 @@
+import bytes from 'bytes';
+export default {
+    format(valueInBytes, options) {
+        return bytes.format(valueInBytes, options);
+    },
+    parse(unit) {
+        if (typeof unit === 'number') {
+            return unit;
+        }
+        return bytes.parse(unit);
+    },
+};

package/build/src/string/change_case.d.ts

@@ -0,0 +1,13 @@
+export declare function titleCase(input: string): string;
+export declare function camelCase(value: string): string;
+export declare function snakeCase(value: string): string;
+export declare function dashCase(value: string, options?: {
+    capitalize?: boolean;
+}): string;
+export declare function pascalCase(value: string): string;
+export declare function capitalCase(value: string): string;
+export declare function sentenceCase(value: string): string;
+export declare function dotCase(value: string, options?: {
+    lowerCase?: boolean;
+}): string;
+export declare function noCase(value: string, transform?: (part: string, index: number, parts: string[]) => string): string;

package/build/src/string/change_case.js

@@ -0,0 +1,75 @@
+import * as changeCase from 'case-anything';
+const NO_CASE_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+const NO_CASE_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+const SMALL_WORDS = /\b(?:an?d?|a[st]|because|but|by|en|for|i[fn]|neither|nor|o[fnr]|only|over|per|so|some|tha[tn]|the|to|up|upon|vs?\.?|versus|via|when|with|without|yet)\b/i;
+const TOKENS = /[^\s:–—-]+|./g;
+const WHITESPACE = /\s/;
+const IS_MANUAL_CASE = /.(?=[A-Z]|\..)/;
+const ALPHANUMERIC_PATTERN = /[A-Za-z0-9\u00C0-\u00FF]/;
+export function titleCase(input) {
+    let output = '';
+    let result;
+    while ((result = TOKENS.exec(input)) !== null) {
+        const { 0: token, index } = result;
+        if (!IS_MANUAL_CASE.test(token) &&
+            (!SMALL_WORDS.test(token) || index === 0 || index + token.length === input.length) &&
+            (input.charAt(index + token.length) !== ':' ||
+                WHITESPACE.test(input.charAt(index + token.length + 1)))) {
+            output += token.replace(ALPHANUMERIC_PATTERN, (char) => char.toUpperCase());
+            continue;
+        }
+        output += token;
+    }
+    return output;
+}
+export function camelCase(value) {
+    return changeCase.camelCase(value);
+}
+export function snakeCase(value) {
+    return changeCase.snakeCase(value);
+}
+export function dashCase(value, options) {
+    if (options && options.capitalize) {
+        return changeCase.trainCase(value);
+    }
+    return changeCase.kebabCase(value);
+}
+export function pascalCase(value) {
+    return changeCase.pascalCase(value);
+}
+export function capitalCase(value) {
+    return changeCase.capitalCase(value);
+}
+export function sentenceCase(value) {
+    return noCase(value, (input, index) => {
+        const result = input.toLowerCase();
+        if (index === 0) {
+            return input.charAt(0).toUpperCase() + input.substring(1);
+        }
+        return result;
+    });
+}
+export function dotCase(value, options) {
+    const transformedValue = changeCase.dotNotation(value);
+    if (options && options.lowerCase) {
+        return transformedValue.toLowerCase();
+    }
+    return transformedValue;
+}
+export function noCase(value, transform) {
+    let result = NO_CASE_SPLIT_REGEXP.reduce((input, regex) => input.replace(regex, '$1\0$2'), value);
+    result = result.replace(NO_CASE_STRIP_REGEXP, '\0');
+    let start = 0;
+    let end = result.length;
+    while (result.charAt(start) === '\0') {
+        start++;
+    }
+    while (result.charAt(end - 1) === '\0') {
+        end--;
+    }
+    return result
+        .slice(start, end)
+        .split('\0')
+        .map(transform || ((input) => input.toLowerCase()))
+        .join(' ');
+}

package/build/src/string/excerpt.d.ts

@@ -0,0 +1,4 @@
+export declare function excerpt(sentence: string, charactersLimit: number, options?: {
+    completeWords?: boolean;
+    suffix?: string;
+}): string;

package/build/src/string/excerpt.js

@@ -0,0 +1,10 @@
+import truncatise from 'truncatise';
+export function excerpt(sentence, charactersLimit, options) {
+    return truncatise(sentence, {
+        TruncateLength: charactersLimit,
+        Strict: options && options.completeWords === true ? false : true,
+        StripHTML: true,
+        TruncateBy: 'characters',
+        Suffix: options && options.suffix,
+    });
+}

package/build/src/string/interpolate.d.ts

@@ -0,0 +1 @@
+export declare function interpolate(input: string, data: any): string;

package/build/src/{Helpers → string}/interpolate.js

@@ -1,23 +1,9 @@
-"use strict";
-/*
- * @poppinss/utils
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolate = void 0;
 function uncurryThis(fn) {
     return function (...args) {
         return Function.call.apply(fn, args);
     };
 }
 const hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
-/**
- * Parses prop
- */
 function parseProp(data, key) {
     const tokens = key.split('.');
     while (tokens.length) {
@@ -29,13 +15,7 @@ function parseProp(data, key) {
     }
     return data;
 }
-/**
- * A simple function interpolate values inside curly braces.
- *
- * @example
- * `interpolate('hello {{ username }}', { username: 'virk' })`
- */
-function interpolate(input, data) {
+export function interpolate(input, data) {
     return input.replace(/(\\)?{{(.*?)}}/g, (_, escapeChar, key) => {
         if (escapeChar) {
             return `{{${key}}}`;
@@ -43,4 +23,3 @@ function interpolate(input, data) {
         return parseProp(data, key.trim());
     });
 }
-exports.interpolate = interpolate;

package/build/src/string/main.d.ts

@@ -0,0 +1,46 @@
+import { random } from './random.js';
+import { excerpt } from './excerpt.js';
+import { ordinal } from './ordinal.js';
+import { truncate } from './truncate.js';
+import { sentence } from './sentence.js';
+import { interpolate } from './interpolate.js';
+import { pluralize } from './pluralize.js';
+import { noCase, dotCase, dashCase, camelCase, snakeCase, titleCase, pascalCase, capitalCase, sentenceCase } from './change_case.js';
+declare function condenseWhitespace(value: string): string;
+declare const string: {
+    excerpt: typeof excerpt;
+    truncate: typeof truncate;
+    slug: typeof import("slugify").default;
+    interpolate: typeof interpolate;
+    plural: typeof import("pluralize").plural;
+    pluralize: typeof pluralize;
+    singular: typeof import("pluralize").singular;
+    isPlural: typeof import("pluralize").isPlural;
+    isSingular: typeof import("pluralize").isSingular;
+    camelCase: typeof camelCase;
+    capitalCase: typeof capitalCase;
+    dashCase: typeof dashCase;
+    dotCase: typeof dotCase;
+    noCase: typeof noCase;
+    pascalCase: typeof pascalCase;
+    sentenceCase: typeof sentenceCase;
+    snakeCase: typeof snakeCase;
+    titleCase: typeof titleCase;
+    random: typeof random;
+    sentence: typeof sentence;
+    condenseWhitespace: typeof condenseWhitespace;
+    seconds: {
+        format(seconds: number, long?: boolean | undefined): string;
+        parse(duration: string | number): number;
+    };
+    milliseconds: {
+        format(milliseconds: number, long?: boolean | undefined): string;
+        parse(duration: string | number): number;
+    };
+    bytes: {
+        format(valueInBytes: number, options?: import("bytes").BytesOptions | undefined): string;
+        parse(unit: string | number): number;
+    };
+    ordinal: typeof ordinal;
+};
+export default string;

package/build/src/string/main.js

@@ -0,0 +1,43 @@
+import bytes from './bytes.js';
+import seconds from './seconds.js';
+import { slug } from './slugify.js';
+import { random } from './random.js';
+import { excerpt } from './excerpt.js';
+import { ordinal } from './ordinal.js';
+import { truncate } from './truncate.js';
+import milliseconds from './milliseconds.js';
+import { sentence } from './sentence.js';
+import { interpolate } from './interpolate.js';
+import { plural, pluralize, singular, isPlural, isSingular } from './pluralize.js';
+import { noCase, dotCase, dashCase, camelCase, snakeCase, titleCase, pascalCase, capitalCase, sentenceCase, } from './change_case.js';
+function condenseWhitespace(value) {
+    return value.trim().replace(/\s{2,}/g, ' ');
+}
+const string = {
+    excerpt,
+    truncate,
+    slug,
+    interpolate,
+    plural,
+    pluralize,
+    singular,
+    isPlural,
+    isSingular,
+    camelCase,
+    capitalCase,
+    dashCase,
+    dotCase,
+    noCase,
+    pascalCase,
+    sentenceCase,
+    snakeCase,
+    titleCase,
+    random,
+    sentence,
+    condenseWhitespace,
+    seconds,
+    milliseconds,
+    bytes,
+    ordinal,
+};
+export default string;

package/build/src/string/milliseconds.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    format(milliseconds: number, long?: boolean): string;
+    parse(duration: string | number): number;
+};
+export default _default;

package/build/src/string/milliseconds.js

@@ -0,0 +1,16 @@
+import { parse, format } from '@lukeed/ms';
+export default {
+    format(milliseconds, long) {
+        return format(milliseconds, long);
+    },
+    parse(duration) {
+        if (typeof duration === 'number') {
+            return duration;
+        }
+        const milliseconds = parse(duration);
+        if (!milliseconds) {
+            throw new Error(`Invalid duration expression "${duration}"`);
+        }
+        return milliseconds;
+    },
+};

package/build/src/string/ordinal.d.ts

@@ -0,0 +1 @@
+export declare function ordinal(value: string | number): string;

package/build/src/string/ordinal.js

@@ -0,0 +1,21 @@
+export function ordinal(value) {
+    const transformedValue = Math.abs(typeof value === 'string' ? Number.parseInt(value) : value);
+    if (!Number.isFinite(transformedValue) || Number.isNaN(transformedValue)) {
+        throw new Error('Cannot ordinalize invalid or infinite numbers');
+    }
+    const percent = transformedValue % 100;
+    if (percent >= 10 && percent <= 20) {
+        return `${value}th`;
+    }
+    const decimal = transformedValue % 10;
+    switch (decimal) {
+        case 1:
+            return `${value}st`;
+        case 2:
+            return `${value}nd`;
+        case 3:
+            return `${value}rd`;
+        default:
+            return `${value}th`;
+    }
+}

package/build/src/string/pluralize.d.ts

@@ -0,0 +1,12 @@
+import { default as pluralizePkg } from 'pluralize';
+export declare function pluralize(word: string, count?: number, inclusive?: boolean): string;
+export declare namespace pluralize {
+    var addPluralRule: typeof pluralizePkg.addPluralRule;
+    var addSingularRule: typeof pluralizePkg.addSingularRule;
+    var addIrregularRule: typeof pluralizePkg.addIrregularRule;
+    var addUncountableRule: typeof pluralizePkg.addUncountableRule;
+}
+export declare const plural: typeof pluralizePkg.plural;
+export declare const singular: typeof pluralizePkg.singular;
+export declare const isPlural: typeof pluralizePkg.isPlural;
+export declare const isSingular: typeof pluralizePkg.isSingular;

package/build/src/string/pluralize.js

@@ -0,0 +1,12 @@
+import { default as pluralizePkg } from 'pluralize';
+export function pluralize(word, count, inclusive) {
+    return pluralizePkg(word, count, inclusive);
+}
+pluralize.addPluralRule = pluralizePkg.addPluralRule;
+pluralize.addSingularRule = pluralizePkg.addSingularRule;
+pluralize.addIrregularRule = pluralizePkg.addIrregularRule;
+pluralize.addUncountableRule = pluralizePkg.addUncountableRule;
+export const plural = pluralizePkg.plural;
+export const singular = pluralizePkg.singular;
+export const isPlural = pluralizePkg.isPlural;
+export const isSingular = pluralizePkg.isSingular;

package/build/src/string/random.d.ts

@@ -0,0 +1 @@
+export declare function random(size: number): string;

package/build/src/string/random.js

@@ -0,0 +1,7 @@
+import { randomBytes } from 'node:crypto';
+import { base64 } from '../base64.js';
+export function random(size) {
+    const bits = (size + 1) * 6;
+    const buffer = randomBytes(Math.ceil(bits / 8));
+    return base64.urlEncode(buffer).slice(0, size);
+}

package/build/src/string/seconds.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    format(seconds: number, long?: boolean): string;
+    parse(duration: string | number): number;
+};
+export default _default;

package/build/src/string/seconds.js

@@ -0,0 +1,16 @@
+import { parse, format } from '@lukeed/ms';
+export default {
+    format(seconds, long) {
+        return format(seconds * 1000, long);
+    },
+    parse(duration) {
+        if (typeof duration === 'number') {
+            return duration;
+        }
+        const milliseconds = parse(duration);
+        if (!milliseconds) {
+            throw new Error(`Invalid duration expression "${duration}"`);
+        }
+        return Math.floor(milliseconds / 1000);
+    },
+};

package/build/src/string/sentence.d.ts

@@ -0,0 +1,5 @@
+export declare function sentence(values: any[], options?: {
+    separator?: string;
+    pairSeparator?: string;
+    lastSeparator?: string;
+}): string;

package/build/src/string/sentence.js

@@ -0,0 +1,13 @@
+export function sentence(values, options) {
+    if (values.length === 0) {
+        return '';
+    }
+    if (values.length === 1) {
+        return values[0];
+    }
+    if (values.length === 2) {
+        return `${values[0]}${options?.pairSeparator || ' and '}${values[1]}`;
+    }
+    const normalized = Object.assign({ separator: ', ', lastSeparator: ', and ' }, options);
+    return `${values.slice(0, -1).join(normalized.separator)}${normalized.lastSeparator}${values[values.length - 1]}`;
+}

package/build/src/string/slugify.d.ts

@@ -0,0 +1,2 @@
+import { default as slugifyPkg } from 'slugify';
+export declare const slug: typeof slugifyPkg.default;

package/build/src/string/slugify.js

@@ -0,0 +1,2 @@
+import { default as slugifyPkg } from 'slugify';
+export const slug = slugifyPkg;

package/build/src/string/truncate.d.ts

@@ -0,0 +1,4 @@
+export declare function truncate(sentence: string, charactersLimit: number, options?: {
+    completeWords?: boolean;
+    suffix?: string;
+}): string;

package/build/src/string/truncate.js

@@ -0,0 +1,10 @@
+import truncatise from 'truncatise';
+export function truncate(sentence, charactersLimit, options) {
+    return truncatise(sentence, {
+        TruncateLength: charactersLimit,
+        Strict: options && options.completeWords === true ? false : true,
+        StripHTML: false,
+        TruncateBy: 'characters',
+        Suffix: options && options.suffix,
+    });
+}

package/build/src/types.d.ts

@@ -0,0 +1,14 @@
+declare type ScanFsBaseOptions = {
+    ignoreMissingRoot?: boolean;
+    filter?: (filePath: string, index: number) => boolean;
+    sort?: (current: string, next: string) => number;
+};
+export declare type ImportAllFilesOptions = ScanFsBaseOptions & {
+    transformKeys?: (keys: string[]) => string[];
+};
+export declare type ReadAllFilesOptions = ScanFsBaseOptions & {
+    pathType?: 'relative' | 'unixRelative' | 'absolute' | 'unixAbsolute' | 'url';
+};
+export declare type JSONReplacer = (this: any, key: string, value: any) => any;
+export declare type JSONReviver = (this: any, key: string, value: any) => any;
+export {};

package/build/src/types.js

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

package/lodash/lodash.types.d.ts

@@ -0,0 +1,44 @@
+/*
+ * @poppinss/utils
+ *
+ * (c) Poppinss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+type PropertyName = string | number | symbol
+type PropertyNames = PropertyName | ReadonlyArray<PropertyName>
+
+/**
+ * Instead of using lodash as a dependency (which is around 4MB), we create a
+ * customized build of lodash with only the following methods.
+ *
+ * I know that 4MB is not a huge deal on the server, but I am okay shoving that
+ * off, if the work to maintain custom build is not too much.
+ *
+ * How about Lodash per methods packages?
+ * They are out of date from the main lodash. That is the main problem
+ */
+declare module '@poppinss/utils/lodash' {
+  type LodashMethods = {
+    pick: <T>(object: T | null | undefined, ...props: Array<PropertyNames>) => Partial<T>
+    omit: <T extends object>(
+      object: T | null | undefined,
+      ...paths: Array<PropertyNames>
+    ) => Partial<T>
+    has: <T>(object: T, path: PropertyNames) => boolean
+    get: (object: any, path: PropertyNames, defaultValue?: any) => any
+    set: (object: any, path: PropertyNames, value: any) => any
+    unset: (object: any, path: PropertyNames) => boolean
+    mergeWith: (object: any, ...otherArgs: any[]) => any
+    merge: (object: any, ...otherArgs: any[]) => any
+    size: (collection: object | string | null | undefined) => number
+    clone: <T>(value: T) => T
+    cloneDeep: <T>(value: T) => T
+    toPath: (value: any) => string[]
+  }
+
+  const lodash: LodashMethods
+  export default lodash
+}