@poppinss/utils 6.5.0-2 → 6.5.0-4

package/build/index.js

@@ -1,24 +1,373 @@
-import { fileURLToPath } from 'node:url';
-import { dirname as pathDirname } from 'node:path';
-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 { isScriptFile } from './src/is_script_file.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 } from './src/exceptions/runtime_exception.js';
-export { InvalidArgumentsException } from './src/exceptions/invalid_arguments_exception.js';
-export function getDirname(url) {
-    return pathDirname(getFilename(url));
-}
-export function getFilename(url) {
-    return fileURLToPath(url);
+import {
+  base64,
+  milliseconds_default
+} from "./chunk-PWRXO3NF.js";
+import {
+  main_default
+} from "./chunk-XHQBV7AF.js";
+
+// index.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as pathDirname } from "node:path";
+
+// src/compose.ts
+function compose(superclass, ...mixins) {
+  return mixins.reduce((c, mixin) => mixin(c), superclass);
 }
+
+// src/exception.ts
+import { format } from "node:util";
+var Exception = class extends Error {
+  /**
+   * Name of the class that raised the exception.
+   */
+  name;
+  /**
+   * A status code for the error. Usually helpful when converting errors
+   * to HTTP responses.
+   */
+  status;
+  constructor(message, options) {
+    super(message, options);
+    const ErrorConstructor = this.constructor;
+    this.name = ErrorConstructor.name;
+    this.message = message || ErrorConstructor.message || "";
+    this.status = options?.status || ErrorConstructor.status || 500;
+    const code = options?.code || ErrorConstructor.code;
+    if (code !== void 0) {
+      this.code = code;
+    }
+    const help = ErrorConstructor.help;
+    if (help !== void 0) {
+      this.help = help;
+    }
+    Error.captureStackTrace(this, ErrorConstructor);
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+  toString() {
+    if (this.code) {
+      return `${this.name} [${this.code}]: ${this.message}`;
+    }
+    return `${this.name}: ${this.message}`;
+  }
+};
+function createError(message, code, status) {
+  return class extends Exception {
+    static message = message;
+    static code = code;
+    static status = status;
+    constructor(args, options) {
+      super(format(message, ...args || []), options);
+    }
+  };
+}
+
+// src/exceptions/runtime_exception.ts
+var RuntimeException = class extends Exception {
+  static code = "E_RUNTIME_EXCEPTION";
+  static status = 500;
+};
+
+// src/import_default.ts
+async function importDefault(importFn, filePath) {
+  const moduleExports = await importFn();
+  if (!("default" in moduleExports)) {
+    const errorMessage = filePath ? `Missing "export default" in module "${filePath}"` : `Missing "export default" from lazy import "${importFn}"`;
+    throw new RuntimeException(errorMessage, {
+      cause: {
+        source: importFn
+      }
+    });
+  }
+  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 "node:url";
+import lodash2 from "@poppinss/utils/lodash";
+import { extname as extname2, relative, sep } from "node:path";
+
+// src/fs_read_all.ts
+import { join } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/slash.ts
+import { default as default2 } from "slash";
+
+// 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(default2(relativePath));
+      break;
+    case "unixAbsolute":
+      files.push(default2(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 "node: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, { assert: { 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
+var MessageBuilder = class {
+  #getExpiryDate(expiresIn) {
+    if (!expiresIn) {
+      return void 0;
+    }
+    const expiryMs = milliseconds_default.parse(expiresIn);
+    return new Date(Date.now() + expiryMs);
+  }
+  /**
+   * Returns a boolean telling, if message has been expired or not
+   */
+  #isExpired(message) {
+    if (!message.expiryDate) {
+      return false;
+    }
+    const expiryDate = new Date(message.expiryDate);
+    return Number.isNaN(expiryDate.getTime()) || expiryDate < /* @__PURE__ */ new Date();
+  }
+  /**
+   * Builds a message by encoding expiry date and purpose inside it.
+   */
+  build(message, expiresIn, purpose) {
+    const expiryDate = this.#getExpiryDate(expiresIn);
+    return main_default.safeStringify({ message, purpose, expiryDate });
+  }
+  /**
+   * Verifies the message for expiry and purpose.
+   */
+  verify(message, purpose) {
+    const parsed = main_default.safeParse(message);
+    if (typeof parsed !== "object" || !parsed) {
+      return null;
+    }
+    if (!parsed.message) {
+      return null;
+    }
+    if (parsed.purpose !== purpose) {
+      return null;
+    }
+    if (this.#isExpired(parsed)) {
+      return null;
+    }
+    return parsed.message;
+  }
+};
+
+// src/object_builder.ts
+var ObjectBuilder = class {
+  #ignoreNull;
+  values;
+  constructor(initialValue, ignoreNull) {
+    this.values = initialValue;
+    this.#ignoreNull = ignoreNull === true ? true : false;
+  }
+  add(key, value) {
+    if (value === void 0) {
+      return this;
+    }
+    if (this.#ignoreNull === true && value === null) {
+      return this;
+    }
+    ;
+    this.values[key] = value;
+    return this;
+  }
+  /**
+   * Remove key from the object
+   */
+  remove(key) {
+    delete this.values[key];
+    return this;
+  }
+  /**
+   * Find if a value exists
+   */
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  /**
+   * Get the existing value for a given key
+   */
+  get(key) {
+    return this.values[key];
+  }
+  /**
+   * Get the underlying constructed object
+   */
+  toObject() {
+    return this.values;
+  }
+};
+
+// src/safe_equal.ts
+import { Buffer } from "node:buffer";
+import { timingSafeEqual } from "node: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/exceptions/invalid_arguments_exception.ts
+var InvalidArgumentsException = class extends Exception {
+  static code = "E_INVALID_ARGUMENTS_EXCEPTION";
+  static status = 500;
+};
+
+// index.ts
+function getDirname(url) {
+  return pathDirname(getFilename(url));
+}
+function getFilename(url) {
+  return fileURLToPath3(url);
+}
+export {
+  Exception,
+  InvalidArgumentsException,
+  MessageBuilder,
+  ObjectBuilder,
+  RuntimeException,
+  base64,
+  compose,
+  createError,
+  defineStaticProperty,
+  flatten,
+  fsImportAll,
+  fsReadAll,
+  getDirname,
+  getFilename,
+  importDefault,
+  isScriptFile,
+  naturalSort,
+  safeEqual,
+  default2 as slash
+};

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

@@ -1,7 +1,19 @@
-import { safeParse } from './safe_parse.js';
-import { safeStringify } from './safe_stringify.js';
+import { JSONReviver, JSONReplacer } from '../types.js';
+
+/**
+ * A drop-in replacement for JSON.parse with prototype poisoning protection.
+ */
+declare function safeParse(jsonString: string, reviver?: JSONReviver): any;
+
+/**
+ * String Javascript values to a JSON string. Handles circular
+ * references and bigints
+ */
+declare function safeStringify(value: any, replacer?: JSONReplacer, space?: string | number): string | undefined;
+
 declare const json: {
     safeParse: typeof safeParse;
     safeStringify: typeof safeStringify;
 };
-export default json;
+
+export { json as default };

package/build/src/json/main.js

@@ -1,7 +1,6 @@
-import { safeParse } from './safe_parse.js';
-import { safeStringify } from './safe_stringify.js';
-const json = {
-    safeParse,
-    safeStringify,
+import {
+  main_default
+} from "../../chunk-XHQBV7AF.js";
+export {
+  main_default as default
 };
-export default json;

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

@@ -1,22 +1,127 @@
-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';
+import * as bytes from 'bytes';
+import * as slugify from 'slugify';
+import pluralizePkg from 'pluralize';
+
+/**
+ * Generates a random string of a given size
+ */
+declare function random(size: number): string;
+
+/**
+ * Truncate a sentence to be under a certain characters limit and strip
+ * out HTML tags from it.
+ *
+ * Optionally, you can force the truncate logic to complete words, which
+ * may exceed the defined characters limit.
+ */
+declare function excerpt(sentence: string, charactersLimit: number, options?: {
+    completeWords?: boolean;
+    suffix?: string;
+}): string;
+
+/**
+ * Ordinalize a give number or string
+ */
+declare function ordinal(value: string | number): string;
+
+/**
+ * Truncate a sentence to be under a certain characters limit.
+ *
+ * Optionally, you can force the truncate logic to complete words, which
+ * may exceed the defined characters limit.
+ */
+declare function truncate(sentence: string, charactersLimit: number, options?: {
+    completeWords?: boolean;
+    suffix?: string;
+}): string;
+
+/**
+ * Convert an array of values to a sentence.
+ */
+declare function sentence(values: any[], options?: {
+    separator?: string;
+    pairSeparator?: string;
+    lastSeparator?: string;
+}): string;
+
+/**
+ * A simple function interpolate values inside curly braces.
+ *
+ * ```
+ * interpolate('hello {{ username }}', { username: 'virk' })
+ * ```
+ */
+declare function interpolate(input: string, data: any): string;
+
+/**
+ * Pluralize a word based upon the count. The method returns the
+ * singular form when count is 1.
+ */
+declare function pluralize(word: string, count?: number, inclusive?: boolean): string;
+declare namespace pluralize {
+    var addPluralRule: typeof pluralizePkg.addPluralRule;
+    var addSingularRule: typeof pluralizePkg.addSingularRule;
+    var addIrregularRule: typeof pluralizePkg.addIrregularRule;
+    var addUncountableRule: typeof pluralizePkg.addUncountableRule;
+}
+
+/**
+ * The method is a copy/paste from the "title-case" package. They have
+ * a dependency on "tslib", which I don't want.
+ */
+declare function titleCase(input: string): string;
+/**
+ * Convert string to camelcase
+ */
+declare function camelCase(value: string): string;
+/**
+ * Convert string to snakecase
+ */
+declare function snakeCase(value: string): string;
+/**
+ * Convert string to dashcase
+ */
+declare function dashCase(value: string, options?: {
+    capitalize?: boolean;
+}): string;
+/**
+ * Convert string to pascal case
+ */
+declare function pascalCase(value: string): string;
+/**
+ * Convert string to capital case
+ */
+declare function capitalCase(value: string): string;
+/**
+ * Convert string to sentence case
+ */
+declare function sentenceCase(value: string): string;
+/**
+ * Convert string to dot case
+ */
+declare function dotCase(value: string, options?: {
+    lowerCase?: boolean;
+}): string;
+/**
+ * Remove all sort of casing from the string. Copy-pasted from
+ * "no-case" package with slight modifications.
+ */
+declare function noCase(value: string, transform?: (part: string, index: number, parts: string[]) => string): string;
+
+/**
+ * Condense multiple whitespaces from a string
+ */
 declare function condenseWhitespace(value: string): string;
 declare const string: {
     excerpt: typeof excerpt;
     truncate: typeof truncate;
-    slug: typeof import("slugify").default;
+    slug: typeof slugify.default;
     interpolate: typeof interpolate;
-    plural: typeof import("pluralize").plural;
+    plural: typeof pluralize.plural;
     pluralize: typeof pluralize;
-    singular: typeof import("pluralize").singular;
-    isPlural: typeof import("pluralize").isPlural;
-    isSingular: typeof import("pluralize").isSingular;
+    singular: typeof pluralize.singular;
+    isPlural: typeof pluralize.isPlural;
+    isSingular: typeof pluralize.isSingular;
     camelCase: typeof camelCase;
     capitalCase: typeof capitalCase;
     dashCase: typeof dashCase;
@@ -38,9 +143,10 @@ declare const string: {
         parse(duration: string | number): number;
     };
     bytes: {
-        format(valueInBytes: number, options?: import("bytes").BytesOptions | undefined): string;
+        format(valueInBytes: number, options?: bytes.BytesOptions | undefined): string;
         parse(unit: string | number): number;
     };
     ordinal: typeof ordinal;
 };
-export default string;
+
+export { string as default };

package/build/src/string/main.js

@@ -1,43 +1,7 @@
-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,
+import {
+  main_default
+} from "../../chunk-OKRMWJO4.js";
+import "../../chunk-PWRXO3NF.js";
+export {
+  main_default as default
 };
-export default string;