@splendidlabz/utils 1.14.0 → 1.15.0

package/dist/esm/lib/objects/omit-empty.js

@@ -1,12 +1,17 @@
-function omitEmpty(obj, shallow = false) {
-  if (typeof obj !== "object" || obj === null) return obj;
-  if (obj instanceof Date) return obj;
+import { isPlainObject } from "../checks.js";
+function omitEmpty(obj, options = {}) {
+  const { shallow = false, omitFalsey = false } = typeof options === "boolean" ? { shallow: options } : options;
+  if (!isPlainObject(obj) && !Array.isArray(obj)) return obj;
   const result = Array.isArray(obj) ? [] : {};
   for (const [key, value] of Object.entries(obj)) {
-    if (value === null || value === void 0 || value === "" || typeof value === "object" && !(value instanceof Date) && Object.keys(value).length === 0) {
+    if (value === null || value === void 0 || value === "") continue;
+    if (omitFalsey && !value) continue;
+    if ((isPlainObject(value) || Array.isArray(value)) && Object.keys(value).length === 0) {
       continue;
     }
-    result[key] = shallow ? value : omitEmpty(value);
+    const filteredValue = shallow ? value : omitEmpty(value, { omitFalsey });
+    if (Array.isArray(result)) result.push(filteredValue);
+    else result[key] = filteredValue;
   }
   return result;
 }

package/dist/esm/lib/objects/remove-invalid.js

@@ -0,0 +1,28 @@
+import { isPlainObject } from "../checks.js";
+function removeInvalid(values, schema) {
+  if (!schema) return values;
+  if (Array.isArray(values)) {
+    const kept2 = [];
+    for (const item of values) {
+      if (!isValid(item, schema)) continue;
+      kept2.push(removeInvalid(item, schema));
+    }
+    return kept2;
+  }
+  if (!isPlainObject(values) || !isPlainObject(schema)) return values;
+  const kept = {};
+  for (const [key, value] of Object.entries(values)) {
+    const keySchema = schema[key];
+    if (!isValid(value, keySchema)) continue;
+    kept[key] = removeInvalid(value, keySchema);
+  }
+  return kept;
+}
+function isValid(value, pattern) {
+  if (typeof value !== "string") return true;
+  if (typeof pattern !== "string" && !(pattern instanceof RegExp)) return true;
+  return new RegExp(pattern).test(value);
+}
+export {
+  removeInvalid
+};

package/dist/esm/lib/objects/trim-values.js

@@ -0,0 +1,14 @@
+import { isPlainObject } from "../checks.js";
+function trimValues(values) {
+  if (typeof values === "string") return values.trim();
+  if (Array.isArray(values)) return values.map(trimValues);
+  if (!isPlainObject(values)) return values;
+  const trimmed = {};
+  for (const [key, value] of Object.entries(values)) {
+    trimmed[key] = trimValues(value);
+  }
+  return trimmed;
+}
+export {
+  trimValues
+};

package/dist/esm/node/pkce.js

@@ -1,18 +1,15 @@
-import crypto from "node:crypto";
-import { randomString } from "./random-string.js";
+import { createHash, randomBytes } from "node:crypto";
 async function PKCE() {
-  const codeVerifier = await randomString();
-  const codeChallenge = await getCodeChallenge(codeVerifier);
+  const codeVerifier = randomBytes(32).toString("base64url");
   return {
-    state: await randomString(),
+    state: randomBytes(32).toString("base64url"),
     code_verifier: codeVerifier,
-    code_challenge: codeChallenge,
+    code_challenge: getCodeChallenge(codeVerifier),
     code_challenge_method: "S256"
   };
 }
 function getCodeChallenge(verifier) {
-  const hash = crypto.createHash("sha256").update(verifier).digest();
-  return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  return createHash("sha256").update(verifier).digest("base64url");
 }
 export {
   PKCE,

package/dist/types/dom/index.d.cts

@@ -18,7 +18,7 @@ export { intersectionObserver } from './observers/intersection-observer.cjs';
 export { mutationObserver } from './observers/mutation-observer.cjs';
 export { resizeObserver } from './observers/resize-observer.cjs';
 export { ScrollObserverOptions, scrollObserver } from './observers/scroll-observer.cjs';
-export { PKCE } from './pkce.cjs';
+export { PKCE, PkceParams, getCodeChallenge } from './pkce.cjs';
 export { queryParams } from './query-params.cjs';
 export { randomString, uuid } from './random-string.cjs';
 export { sanitize } from './sanitize.cjs';

package/dist/types/dom/pkce.d.cts

@@ -1,8 +1,33 @@
-declare function PKCE(): Promise<{
+/**
+ * PKCE
+ *
+ * @typedef {object} PkceParams The authorization request's parameters, named as the query string wants them.
+ * @property {string} state
+ * @property {string} code_verifier Held back until the token request sends it.
+ * @property {string} code_challenge
+ * @property {'S256'} code_challenge_method
+ *
+ * @returns {Promise<PkceParams>}
+ */
+declare function PKCE(): Promise<PkceParams>;
+/**
+ * getCodeChallenge
+ *
+ * @param {string} verifier
+ * @returns {Promise<string>}
+ */
+declare function getCodeChallenge(verifier: string): Promise<string>;
+/**
+ * The authorization request's parameters, named as the query string wants them.
+ */
+type PkceParams = {
     state: string;
+    /**
+     * Held back until the token request sends it.
+     */
     code_verifier: string;
     code_challenge: string;
-    code_challenge_method: string;
-}>;
+    code_challenge_method: "S256";
+};
 
-export { PKCE };
+export { PKCE, type PkceParams, getCodeChallenge };

package/dist/types/lib/checks.d.cts

@@ -8,6 +8,16 @@
  * isObject(null) // false
  */
 declare function isObject(x: unknown): boolean;
+/**
+ * Checks if a value is an object literal — one whose prototype is `Object.prototype` or `null`. Class instances and platform objects like `File`, `Blob`, `Date` and `Map` are excluded, so code that walks an object's entries can leave them intact.
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is an object literal
+ * @example
+ * isPlainObject({}) // true
+ * isPlainObject(new File([], 'a.png')) // false
+ * isPlainObject(new Date()) // false
+ */
+declare function isPlainObject(x: unknown): boolean;
 /**
  * Checks if a value is an array
  * @param {unknown} x - The value to check
@@ -27,7 +37,7 @@ declare function isArray(x: unknown): boolean;
  * notObject({}) // false
  */
 declare function notObject(x: unknown): boolean;
-declare function getType(x: any): "string" | "integer" | "float" | "boolean" | "function" | "undefined" | "symbol" | "bigint" | "array" | "object" | "unknown";
+declare function getType(x: any): "array" | "string" | "integer" | "float" | "boolean" | "function" | "undefined" | "symbol" | "bigint" | "object" | "unknown";
 declare function isFunction(x: any): boolean;
 
-export { getType, isArray, isFunction, isObject, notObject };
+export { getType, isArray, isFunction, isObject, isPlainObject, notObject };

package/dist/types/lib/form/sanitize.d.cts

@@ -46,7 +46,7 @@ type SanitizeOptions = {
  */
 declare function sanitizeArray(arr: any[], { sanitizer, ...rest }: SanitizeOptions): any[];
 /**
- * Sanitizes all string values in an object recursively.
+ * Sanitizes all string values in an object recursively. An alias for `sanitize`, which already walks objects and arrays and leaves every other value alone.
  * Throws if no sanitizer function is not provided.
  * Any additional properties in options are passed through to the sanitizer function.
  *
@@ -55,6 +55,6 @@ declare function sanitizeArray(arr: any[], { sanitizer, ...rest }: SanitizeOptio
  * @throws {Error} If sanitizer function is not provided
  * @returns {Object} New object with sanitized values
  */
-declare function sanitizeObject(obj: any, { sanitizer, ...options }?: SanitizeOptions): any;
+declare function sanitizeObject(obj: any, options?: SanitizeOptions): any;
 
 export { type SanitizeOptions, sanitize, sanitizeArray, sanitizeObject };

package/dist/types/lib/index.d.cts

@@ -5,7 +5,7 @@ export { sort } from './arrays/sort.cjs';
 export { splitArray } from './arrays/split-array.cjs';
 export { uniqueArray } from './arrays/unique.cjs';
 export { AuthManager, RouteManager } from './auth/route-manager.cjs';
-export { getType, isArray, isFunction, isObject, notObject } from './checks.cjs';
+export { getType, isArray, isFunction, isObject, isPlainObject, notObject } from './checks.cjs';
 export { hexToRgb } from './colors.cjs';
 export { DAYS } from './date/days.cjs';
 export { MONTHS } from './date/months.cjs';
@@ -33,8 +33,10 @@ export { concatMix, createMix, mix } from './objects/mix/mix.cjs';
 export { getNestedProperty, getNestedProperty2, getNestedValue } from './objects/nested-property.cjs';
 export { normalizeObject } from './objects/normalize-object.cjs';
 export { omitEmpty } from './objects/omit-empty.cjs';
+export { removeInvalid } from './objects/remove-invalid.cjs';
 export { sizeOf } from './objects/size.cjs';
 export { splitObject } from './objects/split.cjs';
+export { trimValues } from './objects/trim-values.cjs';
 export { reject } from './promises/reject.cjs';
 export { createSSE, parseSSE } from './sse.cjs';
 export { toCamel, toKebab, toLower, toPascal, toSentence, toSlug, toTitle, toUpper } from './strings/convert-case/convert-case.cjs';

package/dist/types/lib/objects/index.d.cts

@@ -9,5 +9,7 @@ export { concatMix, createMix, mix } from './mix/mix.cjs';
 export { getNestedProperty, getNestedProperty2, getNestedValue } from './nested-property.cjs';
 export { normalizeObject } from './normalize-object.cjs';
 export { omitEmpty } from './omit-empty.cjs';
+export { removeInvalid } from './remove-invalid.cjs';
 export { sizeOf } from './size.cjs';
 export { splitObject } from './split.cjs';
+export { trimValues } from './trim-values.cjs';

package/dist/types/lib/objects/omit-empty.d.cts

@@ -1,3 +1,26 @@
-declare function omitEmpty(obj: any, shallow?: boolean): any;
+/**
+ * Drop the keys holding nothing — null, undefined, an empty string, an empty object or an empty array.
+ *
+ * @overload
+ * @param {object} obj Object to filter.
+ * @param {object} [options]
+ * @param {boolean} [options.shallow=false] Leave nested values alone.
+ * @param {boolean} [options.omitFalsey=false] Drop 0, false and NaN too.
+ * @returns {object} A copy without the empty keys.
+ */
+declare function omitEmpty(obj: object, options?: {
+    shallow?: boolean;
+    omitFalsey?: boolean;
+}): object;
+/**
+ * Drop the keys holding nothing.
+ *
+ * @overload
+ * @param {object} obj Object to filter.
+ * @param {boolean} shallow Leave nested values alone.
+ * @returns {object} A copy without the empty keys.
+ * @deprecated Pass `{ shallow: true }` instead. The boolean goes in 2.0.0.
+ */
+declare function omitEmpty(obj: object, shallow: boolean): object;
 
 export { omitEmpty };

package/dist/types/lib/objects/remove-invalid.d.cts

@@ -0,0 +1,12 @@
+/**
+ * Remove every string that fails the pattern the schema holds for it, in the shape the values came in as.
+ *
+ * The schema mirrors the values: a key holds a pattern for what sits at that key, or another schema for what sits under it. An array takes the schema its key holds and applies it to every element, so nothing in the schema says whether a value is an object or an array — the values answer that.
+ *
+ * @param {any} values
+ * @param {object|string|RegExp} [schema] A pattern, or a record of key to pattern or nested schema.
+ * @returns {any}
+ */
+declare function removeInvalid(values: any, schema?: object | string | RegExp): any;
+
+export { removeInvalid };

package/dist/types/lib/objects/trim-values.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Trims every string a value holds, in the shape it came in as. A Date, a File and anything else that is not a plain object or an array passes through untouched.
+ * @param {any} values
+ * @returns {any}
+ */
+declare function trimValues(values: any): any;
+
+export { trimValues };

package/dist/types/node/index.d.cts

@@ -1,7 +1,7 @@
 export { __dirname, dirname } from './dirname.cjs';
 export { createCache, fileCache, getLastModifiedTime, getLatestModifiedTime, removeFirstSlash } from './file-cache.cjs';
 export { sha256Hash } from './hash.cjs';
-export { PKCE, getCodeChallenge } from './pkce.cjs';
+export { PKCE, PkceParams, getCodeChallenge } from './pkce.cjs';
 export { randomString } from './random-string.cjs';
 export { sanitize } from './sanitize.cjs';
 export { uuid } from './uuid.cjs';

package/dist/types/node/pkce.d.cts

@@ -1,14 +1,33 @@
-declare function PKCE(): Promise<{
-    state: any;
-    code_verifier: any;
-    code_challenge: any;
-    code_challenge_method: string;
-}>;
 /**
- * Generates code challenge in node
+ * PKCE
+ *
+ * @typedef {object} PkceParams The authorization request's parameters, named as the query string wants them.
+ * @property {string} state
+ * @property {string} code_verifier Held back until the token request sends it.
+ * @property {string} code_challenge
+ * @property {'S256'} code_challenge_method
+ *
+ * @returns {Promise<PkceParams>}
+ */
+declare function PKCE(): Promise<PkceParams>;
+/**
+ * getCodeChallenge
+ *
  * @param {string} verifier
- * @returns string
+ * @returns {string}
+ */
+declare function getCodeChallenge(verifier: string): string;
+/**
+ * The authorization request's parameters, named as the query string wants them.
  */
-declare function getCodeChallenge(verifier: string): any;
+type PkceParams = {
+    state: string;
+    /**
+     * Held back until the token request sends it.
+     */
+    code_verifier: string;
+    code_challenge: string;
+    code_challenge_method: "S256";
+};
 
-export { PKCE, getCodeChallenge };
+export { PKCE, type PkceParams, getCodeChallenge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splendidlabz/utils",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "",
   "type": "module",
   "homepage": "https://splendidlabz.com/docs/utils",