@poppinss/utils 6.9.4 → 7.0.0-next.1

package/build/chunk-SKNTF5Q5.js

@@ -0,0 +1,14 @@
+// modules/exception.ts
+import {
+  RuntimeException,
+  InvalidArgumentsException,
+  Exception,
+  createError
+} from "@poppinss/exception";
+
+export {
+  RuntimeException,
+  InvalidArgumentsException,
+  Exception,
+  createError
+};

package/build/chunk-XFX47BKO.js

@@ -0,0 +1,23 @@
+// src/natural_sort.ts
+function naturalSort(current, next) {
+  return current.localeCompare(next, void 0, { numeric: true, sensitivity: "base" });
+}
+
+// src/is_script_file.ts
+import { extname } from "path";
+var JS_MODULES = [".js", ".json", ".cjs", ".mjs"];
+function isScriptFile(filePath) {
+  const ext = extname(filePath);
+  if (JS_MODULES.includes(ext)) {
+    return true;
+  }
+  if (ext === ".ts" && !filePath.endsWith(".d.ts")) {
+    return true;
+  }
+  return false;
+}
+
+export {
+  naturalSort,
+  isScriptFile
+};

package/build/{chunk-XHQBV7AF.js → chunk-YFSCSJNE.js}

@@ -1,4 +1,4 @@
-// src/json/safe_parse.ts
+// modules/json/safe_parse.ts
 import { parse } from "secure-json-parse";
 function safeParse(jsonString, reviver) {
   return parse(jsonString, reviver, {
@@ -7,7 +7,7 @@ function safeParse(jsonString, reviver) {
   });
 }
 
-// src/json/safe_stringify.ts
+// modules/json/safe_stringify.ts
 import { configure } from "safe-stable-stringify";
 var stringify = configure({
   bigint: false,
@@ -27,13 +27,7 @@ function safeStringify(value, replacer, space) {
   return stringify(value, jsonStringifyReplacer(replacer), space);
 }
 
-// src/json/main.ts
-var json = {
+export {
   safeParse,
   safeStringify
 };
-var main_default = json;
-
-export {
-  main_default
-};

package/build/index.d.ts

@@ -1,29 +1,9 @@
 export { Secret } from './src/secret.js';
-export { base64 } from './src/base64.js';
 export { compose } from './src/compose.js';
-export { importDefault } from './src/import_default.js';
-export { defineStaticProperty } from './src/define_static_property.js';
-export { Exception, createError } from './src/exception.js';
 export { flatten } from './src/flatten.js';
-export { fsImportAll } from './src/fs_import_all.js';
-export { fsReadAll } from './src/fs_read_all.js';
+export { safeEqual } from './src/safe_equal.js';
+export { naturalSort } from './src/natural_sort.js';
 export { isScriptFile } from './src/is_script_file.js';
+export { importDefault } from './src/import_default.js';
 export { MessageBuilder } from './src/message_builder.js';
-export { naturalSort } from './src/natural_sort.js';
-export { ObjectBuilder } from './src/object_builder.js';
-export { safeEqual } from './src/safe_equal.js';
-export { slash } from './src/slash.js';
-export { RuntimeException, InvalidArgumentsException } from './src/exceptions/main.js';
-/**
- * Get dirname for a given file path URL
- */
-export declare function getDirname(url: string | URL): string;
-/**
- * Get filename for a given file path URL
- */
-export declare function getFilename(url: string | URL): string;
-/**
- * Join paths to a URL instance or a URL string. The return
- * value will be a file path without the `file:///` protocol.
- */
-export declare function joinToURL(url: string | URL, ...str: string[]): string;
+export { defineStaticProperty } from './src/define_static_property.js';

package/build/index.js

@@ -1,24 +1,14 @@
 import {
-  Exception,
-  createError
-} from "./chunk-H54AK3PI.js";
-import {
-  slash
-} from "./chunk-EJKUJ44Y.js";
-import {
-  InvalidArgumentsException,
   RuntimeException
-} from "./chunk-4V5ON6P7.js";
+} from "./chunk-SKNTF5Q5.js";
 import {
-  main_default
-} from "./chunk-XHQBV7AF.js";
+  isScriptFile,
+  naturalSort
+} from "./chunk-XFX47BKO.js";
 import {
-  __reExport
-} from "./chunk-2KG3PWR4.js";
-
-// index.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { join as pathJoin, dirname as pathDirname } from "path";
+  safeParse,
+  safeStringify
+} from "./chunk-YFSCSJNE.js";
 
 // src/secret.ts
 var REDACTED = "[redacted]";
@@ -60,51 +50,35 @@ var Secret = class _Secret {
   }
 };
 
-// src/base64.ts
-var Base64 = class {
-  encode(data, encoding) {
-    if (typeof data === "string") {
-      return Buffer.from(data, encoding).toString("base64");
-    }
-    if (Buffer.isBuffer(data)) {
-      return data.toString("base64");
-    }
-    return Buffer.from(data).toString("base64");
-  }
-  decode(encoded, encoding = "utf-8", strict = false) {
-    if (Buffer.isBuffer(encoded)) {
-      return encoded.toString(encoding);
-    }
-    const decoded = Buffer.from(encoded, "base64").toString(encoding);
-    const isInvalid = this.encode(decoded, encoding) !== encoded;
-    if (strict && isInvalid) {
-      throw new Error("Cannot decode malformed value");
-    }
-    return isInvalid ? null : decoded;
-  }
-  urlEncode(data, encoding) {
-    const encoded = typeof data === "string" ? this.encode(data, encoding) : this.encode(data);
-    return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
-  }
-  urlDecode(encoded, encoding = "utf-8", strict = false) {
-    if (Buffer.isBuffer(encoded)) {
-      return encoded.toString(encoding);
-    }
-    const decoded = Buffer.from(encoded, "base64").toString(encoding);
-    const isInvalid = this.urlEncode(decoded, encoding) !== encoded;
-    if (strict && isInvalid) {
-      throw new Error("Cannot urlDecode malformed value");
-    }
-    return isInvalid ? null : decoded;
-  }
-};
-var base64 = new Base64();
-
 // src/compose.ts
 function compose(superclass, ...mixins) {
   return mixins.reduce((c, mixin) => mixin(c), superclass);
 }
 
+// src/flatten.ts
+import { flattie } from "flattie";
+function flatten(input, glue, keepNullish) {
+  return flattie(input, glue, keepNullish);
+}
+
+// src/safe_equal.ts
+import { Buffer } from "buffer";
+import { timingSafeEqual } from "crypto";
+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)
+  );
+}
+
 // src/import_default.ts
 async function importDefault(importFn, filePath) {
   const moduleExports = await importFn();
@@ -119,145 +93,6 @@ async function importDefault(importFn, filePath) {
   return moduleExports.default;
 }
 
-// src/define_static_property.ts
-import lodash from "@poppinss/utils/lodash";
-function defineStaticProperty(self, propertyName, {
-  initialValue,
-  strategy
-}) {
-  if (!self.hasOwnProperty(propertyName)) {
-    const value = self[propertyName];
-    if (strategy === "define" || value === void 0) {
-      Object.defineProperty(self, propertyName, {
-        value: initialValue,
-        configurable: true,
-        enumerable: true,
-        writable: true
-      });
-      return;
-    }
-    Object.defineProperty(self, propertyName, {
-      value: typeof strategy === "function" ? strategy(value) : lodash.cloneDeep(value),
-      configurable: true,
-      enumerable: true,
-      writable: true
-    });
-  }
-}
-
-// src/flatten.ts
-import { flattie } from "flattie";
-function flatten(input, glue, keepNullish) {
-  return flattie(input, glue, keepNullish);
-}
-
-// src/fs_import_all.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import lodash2 from "@poppinss/utils/lodash";
-import { extname as extname2, relative, sep } from "path";
-
-// src/fs_read_all.ts
-import { join } from "path";
-import { readdir, stat } from "fs/promises";
-import { fileURLToPath, pathToFileURL } from "url";
-
-// src/natural_sort.ts
-function naturalSort(current, next) {
-  return current.localeCompare(next, void 0, { numeric: true, sensitivity: "base" });
-}
-
-// src/fs_read_all.ts
-function filterDotFiles(fileName) {
-  return fileName[0] !== ".";
-}
-async function readFiles(root, files, options, relativePath) {
-  const location = join(root, relativePath);
-  const stats = await stat(location);
-  if (stats.isDirectory()) {
-    let locationFiles = await readdir(location);
-    await Promise.all(
-      locationFiles.filter(filterDotFiles).map((file) => {
-        return readFiles(root, files, options, join(relativePath, file));
-      })
-    );
-    return;
-  }
-  const pathType = options.pathType || "relative";
-  switch (pathType) {
-    case "relative":
-      files.push(relativePath);
-      break;
-    case "absolute":
-      files.push(location);
-      break;
-    case "unixRelative":
-      files.push(slash(relativePath));
-      break;
-    case "unixAbsolute":
-      files.push(slash(location));
-      break;
-    case "url":
-      files.push(pathToFileURL(location).href);
-  }
-}
-async function fsReadAll(location, options) {
-  const normalizedLocation = typeof location === "string" ? location : fileURLToPath(location);
-  const normalizedOptions = Object.assign({ absolute: false, sort: naturalSort }, options);
-  const files = [];
-  try {
-    await stat(normalizedLocation);
-  } catch (error) {
-    if (normalizedOptions.ignoreMissingRoot) {
-      return [];
-    }
-    throw error;
-  }
-  await readFiles(normalizedLocation, files, normalizedOptions, "");
-  if (normalizedOptions.filter) {
-    return files.filter(normalizedOptions.filter).sort(normalizedOptions.sort);
-  }
-  return files.sort(normalizedOptions.sort);
-}
-
-// src/is_script_file.ts
-import { extname } from "path";
-var JS_MODULES = [".js", ".json", ".cjs", ".mjs"];
-function isScriptFile(filePath) {
-  const ext = extname(filePath);
-  if (JS_MODULES.includes(ext)) {
-    return true;
-  }
-  if (ext === ".ts" && !filePath.endsWith(".d.ts")) {
-    return true;
-  }
-  return false;
-}
-
-// src/fs_import_all.ts
-async function importFile(basePath, fileURL, values, options) {
-  const filePath = fileURLToPath2(fileURL);
-  const fileExtension = extname2(filePath);
-  const collectionKey = relative(basePath, filePath).replace(new RegExp(`${fileExtension}$`), "").split(sep);
-  const exportedValue = fileExtension === ".json" ? await import(fileURL, { with: { type: "json" } }) : await import(fileURL);
-  lodash2.set(
-    values,
-    options.transformKeys ? options.transformKeys(collectionKey) : collectionKey,
-    exportedValue.default ? exportedValue.default : { ...exportedValue }
-  );
-}
-async function fsImportAll(location, options) {
-  options = options || {};
-  const collection = {};
-  const normalizedLocation = typeof location === "string" ? location : fileURLToPath2(location);
-  const files = await fsReadAll(normalizedLocation, {
-    filter: isScriptFile,
-    ...options,
-    pathType: "url"
-  });
-  await Promise.all(files.map((file) => importFile(normalizedLocation, file, collection, options)));
-  return collection;
-}
-
 // src/message_builder.ts
 import string from "@poppinss/string";
 var MessageBuilder = class {
@@ -283,13 +118,13 @@ var MessageBuilder = class {
    */
   build(message, expiresIn, purpose) {
     const expiryDate = this.#getExpiryDate(expiresIn);
-    return main_default.safeStringify({ message, purpose, expiryDate });
+    return safeStringify({ message, purpose, expiryDate });
   }
   /**
    * Verifies the message for expiry and purpose.
    */
   verify(message, purpose) {
-    const parsed = main_default.safeParse(message);
+    const parsed = safeParse(message);
     if (typeof parsed !== "object" || !parsed) {
       return null;
     }
@@ -306,60 +141,39 @@ var MessageBuilder = class {
   }
 };
 
-// src/object_builder.ts
-var object_builder_exports = {};
-__reExport(object_builder_exports, object_builder_star);
-import * as object_builder_star from "@poppinss/object-builder";
-
-// src/safe_equal.ts
-import { Buffer as Buffer2 } from "buffer";
-import { timingSafeEqual } from "crypto";
-function safeEqual(trustedValue, userInput) {
-  if (typeof trustedValue === "string" && typeof userInput === "string") {
-    const trustedLength = Buffer2.byteLength(trustedValue);
-    const trustedValueBuffer = Buffer2.alloc(trustedLength, 0, "utf-8");
-    trustedValueBuffer.write(trustedValue);
-    const userValueBuffer = Buffer2.alloc(trustedLength, 0, "utf-8");
-    userValueBuffer.write(userInput);
-    return timingSafeEqual(trustedValueBuffer, userValueBuffer) && trustedLength === Buffer2.byteLength(userInput);
+// src/define_static_property.ts
+import lodash from "@poppinss/utils/lodash";
+function defineStaticProperty(self, propertyName, {
+  initialValue,
+  strategy
+}) {
+  if (!self.hasOwnProperty(propertyName)) {
+    const value = self[propertyName];
+    if (strategy === "define" || value === void 0) {
+      Object.defineProperty(self, propertyName, {
+        value: initialValue,
+        configurable: true,
+        enumerable: true,
+        writable: true
+      });
+      return;
+    }
+    Object.defineProperty(self, propertyName, {
+      value: typeof strategy === "function" ? strategy(value) : lodash.cloneDeep(value),
+      configurable: true,
+      enumerable: true,
+      writable: true
+    });
   }
-  return timingSafeEqual(
-    Buffer2.from(trustedValue),
-    Buffer2.from(userInput)
-  );
-}
-
-// index.ts
-function getDirname(url) {
-  return pathDirname(getFilename(url));
-}
-function getFilename(url) {
-  return fileURLToPath3(url);
-}
-function joinToURL(url, ...str) {
-  return pathJoin(getDirname(url), ...str);
 }
-var export_ObjectBuilder = object_builder_exports.ObjectBuilder;
 export {
-  Exception,
-  InvalidArgumentsException,
   MessageBuilder,
-  export_ObjectBuilder as ObjectBuilder,
-  RuntimeException,
   Secret,
-  base64,
   compose,
-  createError,
   defineStaticProperty,
   flatten,
-  fsImportAll,
-  fsReadAll,
-  getDirname,
-  getFilename,
   importDefault,
   isScriptFile,
-  joinToURL,
   naturalSort,
-  safeEqual,
-  slash
+  safeEqual
 };

package/build/{src → modules}/assert.js

@@ -1,6 +1,4 @@
-import "../chunk-2KG3PWR4.js";
-
-// src/assert.ts
+// modules/assert.ts
 import { inspect } from "util";
 import { AssertionError } from "assert";
 function assert(value, message) {

package/build/{src → modules}/base64.d.ts

@@ -28,5 +28,5 @@ declare class Base64 {
     urlDecode(encode: string, encoding?: BufferEncoding, strict?: false): string | null;
     urlDecode(encode: Buffer, encoding?: BufferEncoding): string;
 }
-export declare const base64: Base64;
-export {};
+declare const base64: Base64;
+export default base64;

package/build/modules/base64.js

@@ -0,0 +1,43 @@
+// modules/base64.ts
+var Base64 = class {
+  encode(data, encoding) {
+    if (typeof data === "string") {
+      return Buffer.from(data, encoding).toString("base64");
+    }
+    if (Buffer.isBuffer(data)) {
+      return data.toString("base64");
+    }
+    return Buffer.from(data).toString("base64");
+  }
+  decode(encoded, encoding = "utf-8", strict = false) {
+    if (Buffer.isBuffer(encoded)) {
+      return encoded.toString(encoding);
+    }
+    const decoded = Buffer.from(encoded, "base64").toString(encoding);
+    const isInvalid = this.encode(decoded, encoding) !== encoded;
+    if (strict && isInvalid) {
+      throw new Error("Cannot decode malformed value");
+    }
+    return isInvalid ? null : decoded;
+  }
+  urlEncode(data, encoding) {
+    const encoded = typeof data === "string" ? this.encode(data, encoding) : this.encode(data);
+    return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+  }
+  urlDecode(encoded, encoding = "utf-8", strict = false) {
+    if (Buffer.isBuffer(encoded)) {
+      return encoded.toString(encoding);
+    }
+    const decoded = Buffer.from(encoded, "base64").toString(encoding);
+    const isInvalid = this.urlEncode(decoded, encoding) !== encoded;
+    if (strict && isInvalid) {
+      throw new Error("Cannot urlDecode malformed value");
+    }
+    return isInvalid ? null : decoded;
+  }
+};
+var base64 = new Base64();
+var base64_default = base64;
+export {
+  base64_default as default
+};

package/build/modules/exception.d.ts

@@ -0,0 +1 @@
+export { RuntimeException, InvalidArgumentsException, Exception, createError, } from '@poppinss/exception';

package/build/modules/exception.js

@@ -0,0 +1,12 @@
+import {
+  Exception,
+  InvalidArgumentsException,
+  RuntimeException,
+  createError
+} from "../chunk-SKNTF5Q5.js";
+export {
+  Exception,
+  InvalidArgumentsException,
+  RuntimeException,
+  createError
+};

package/build/{src → modules/fs}/fs_import_all.d.ts

@@ -1,4 +1,9 @@
-import { ImportAllFilesOptions } from './types.js';
+export type ImportAllFilesOptions = {
+    ignoreMissingRoot?: boolean;
+    filter?: (filePath: string, index: number) => boolean;
+    sort?: (current: string, next: string) => number;
+    transformKeys?: (keys: string[]) => string[];
+};
 /**
  * Returns an array of file paths from the given location. You can
  * optionally filter and sort files by passing relevant options

package/build/{src → modules/fs}/fs_read_all.d.ts

@@ -1,4 +1,9 @@
-import { ReadAllFilesOptions } from './types.js';
+export type ReadAllFilesOptions = {
+    ignoreMissingRoot?: boolean;
+    filter?: (filePath: string, index: number) => boolean;
+    sort?: (current: string, next: string) => number;
+    pathType?: 'relative' | 'unixRelative' | 'absolute' | 'unixAbsolute' | 'url';
+};
 /**
  * Returns an array of file paths from the given location. You can
  * optionally filter and sort files by passing relevant options

package/build/modules/fs/main.d.ts

@@ -0,0 +1,2 @@
+export * from './fs_read_all.js';
+export * from './fs_import_all.js';

package/build/modules/fs/main.js

@@ -0,0 +1,82 @@
+import {
+  isScriptFile,
+  naturalSort
+} from "../../chunk-XFX47BKO.js";
+
+// modules/fs/fs_read_all.ts
+import string from "@poppinss/string";
+import { join, relative, sep } from "path";
+import { readdir, stat } from "fs/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+async function fsReadAll(location, options) {
+  const normalizedLocation = typeof location === "string" ? location : fileURLToPath(location);
+  const normalizedOptions = Object.assign({ absolute: false, sort: naturalSort }, options);
+  const pathType = normalizedOptions.pathType || "relative";
+  try {
+    await stat(normalizedLocation);
+  } catch (error) {
+    if (normalizedOptions.ignoreMissingRoot) {
+      return [];
+    }
+    throw error;
+  }
+  const dirents = await readdir(normalizedLocation, { recursive: true, withFileTypes: true });
+  const files = dirents.filter((dirent) => {
+    if (!dirent.isFile()) {
+      return false;
+    }
+    if (dirent.name.startsWith(".") || dirent.parentPath.split(sep).some((segment) => segment.startsWith("."))) {
+      return false;
+    }
+    return true;
+  }).map((file) => {
+    switch (pathType) {
+      case "relative":
+        return join(relative(normalizedLocation, file.parentPath), file.name);
+      case "absolute":
+        return join(file.parentPath, file.name);
+      case "unixRelative":
+        return string.toUnixSlash(join(relative(normalizedLocation, file.parentPath), file.name));
+      case "unixAbsolute":
+        return string.toUnixSlash(join(file.parentPath, file.name));
+      case "url":
+        return pathToFileURL(join(file.parentPath, file.name)).href;
+    }
+  });
+  if (normalizedOptions.filter) {
+    return files.filter(normalizedOptions.filter).sort(normalizedOptions.sort);
+  }
+  return files.sort(normalizedOptions.sort);
+}
+
+// modules/fs/fs_import_all.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import lodash from "@poppinss/utils/lodash";
+import { extname, relative as relative2, sep as sep2 } from "path";
+async function importFile(basePath, fileURL, values, options) {
+  const filePath = fileURLToPath2(fileURL);
+  const fileExtension = extname(filePath);
+  const collectionKey = relative2(basePath, filePath).replace(new RegExp(`${fileExtension}$`), "").split(sep2);
+  const exportedValue = fileExtension === ".json" ? await import(fileURL, { with: { type: "json" } }) : await import(fileURL);
+  lodash.set(
+    values,
+    options.transformKeys ? options.transformKeys(collectionKey) : collectionKey,
+    exportedValue.default ? exportedValue.default : { ...exportedValue }
+  );
+}
+async function fsImportAll(location, options) {
+  options = options || {};
+  const collection = {};
+  const normalizedLocation = typeof location === "string" ? location : fileURLToPath2(location);
+  const files = await fsReadAll(normalizedLocation, {
+    filter: isScriptFile,
+    ...options,
+    pathType: "url"
+  });
+  await Promise.all(files.map((file) => importFile(normalizedLocation, file, collection, options)));
+  return collection;
+}
+export {
+  fsImportAll,
+  fsReadAll
+};

package/build/modules/json/main.d.ts

@@ -0,0 +1,2 @@
+export { safeParse } from './safe_parse.js';
+export { safeStringify } from './safe_stringify.js';

package/build/modules/json/main.js

@@ -0,0 +1,8 @@
+import {
+  safeParse,
+  safeStringify
+} from "../../chunk-YFSCSJNE.js";
+export {
+  safeParse,
+  safeStringify
+};

package/build/{src → modules}/json/safe_parse.d.ts

@@ -1,4 +1,4 @@
-import { JSONReviver } from '../types.js';
+export type JSONReviver = (this: any, key: string, value: any) => any;
 /**
  * A drop-in replacement for JSON.parse with prototype poisoning protection.
  */

package/build/{src → modules}/json/safe_stringify.d.ts

@@ -1,4 +1,4 @@
-import { JSONReplacer } from '../types.js';
+export type JSONReplacer = (this: any, key: string, value: any) => any;
 /**
  * String Javascript values to a JSON string. Handles circular
  * references and bigints

package/build/{src → modules}/string/main.js

@@ -1,6 +1,4 @@
-import "../../chunk-2KG3PWR4.js";
-
-// src/string/main.ts
+// modules/string/main.ts
 import string from "@poppinss/string";
 var main_default = string;
 export {