@rzl-zone/utils-js 3.0.2-beta.2 → 3.1.0

package/dist/isPlainObject-BKYaI6a8.d.ts

@@ -1,182 +0,0 @@
-import{N as NonPlainObject}from'./type-data-DDs-u2kq.js';type GetPreciseTypeOptions={
-/** -------------------------------------------------------
-* * ***Specifies the format in which the returned string type should be transformed.***
-* -------------------------------------------------------
-*
-* ℹ️ For special string literals in `SPECIAL_CASES` (`"-Infinity" | "Infinity" | "NaN"`), which will remain unchanged.
-* @default "toLowerCase"
-*
-* @description
-* Supported formats:
-* - `"toLowerCase"` (default) — converts all letters to lowercase.
-*   - ➔ `"result example type"`
-* - `"toDotCase"` — words separated by dots.
-*   - ➔ `"result.example.type"`
-* - `"toCamelCase"` — first word lowercase, subsequent words capitalized.
-*   - ➔ `"resultExampleType"`
-* - `"toKebabCase"` — words separated by hyphens.
-*   - ➔ `"result-example-type"`
-* - `"toSnakeCase"` — words separated by underscores.
-*   - ➔ `"result_example_type"`
-* - `"toPascalCase"` — all words capitalized, no spaces.
-*   - ➔ `"ResultExampleType"`
-* - `"toPascalCaseSpace"` — all words capitalized with spaces between words.
-*   - ➔ `"Result Example Type"`
-* - `"slugify"` — URL-friendly slug (lowercase with hyphens).
-*   - ➔ `"result-example-type"`
-*
-* @note
-* ⚠️ If an invalid value is provided, the function will automatically fallback to the default `"toLowerCase"`.
-*/
-formatCase?:"toPascalCaseSpace"|"toPascalCase"|"toCamelCase"|"toKebabCase"|"toSnakeCase"|"toDotCase"|"slugify"|"toLowerCase";};
-/** ----------------------------------------------------------
-* * ***Returns a detailed and normalized type string for the given value.***
-* ----------------------------------------------------------
-*
-* The returned string is human-readable _**toLowerCase**_ with spaces _***(by default)***_ or
-* formatted according to the `options.formatCase` setting.
-*
-* Handles:
-* - Primitives (`string`, `number`, `boolean`, `null`, `undefined`, `symbol`, `bigint`)
-* - Built-in objects (`Array`, `Map`, `Set`, `Error subclasses`, `Typed Arrays`, etc)
-* - Objects created with `Object.create(null)`
-* - Generator instances
-* - Node.js `Buffer` instances
-* - Proxy detection (returns `"Proxy"` if detected; detection is not 100% accurate)
-* - Uses cached mapping table (`FIXES`) for known types to provide consistent naming
-* - Falls back to constructor name or `Object.prototype.toString` tag
-*
-* @param {*} value - The value to detect the precise type of
-* @param {Object} [options] - Optional configuration
-* @param {"toPascalCaseSpace"|"toLowerCase"|"toPascalCase"|"toCamelCase"|"toKebabCase"|"toSnakeCase"|"toDotCase"|"slugify"} [options.formatCase="toLowerCase"]
-*   - Specifies how the returned type string should be formatted.
-*   - ⚠️ Special string literals in `SPECIAL_CASES` (`"-Infinity" | "Infinity" | "NaN"`)
-*     will remain unchanged even if a different `formatCase` is applied.
-*
-* @returns {string} The normalized and formatted type string
-*
-* @example
-* getPreciseType(123);  // ➔ "number"
-* getPreciseType(null); // ➔ "null"
-* getPreciseType(/regex/,{ formatCase: "toKebabCase" });
-* // ➔ "reg-exp"
-* getPreciseType(function* () {}, { formatCase: "toCamelCase" });
-* // ➔ "generatorFunction"
-* getPreciseType(async function () {}, { formatCase: "toPascalCaseSpace" });
-* // ➔ "Async Function"
-* getPreciseType("NaN", { formatCase: "toKebabCase" });
-* // ➔ "NaN" (SPECIAL_CASES remain)
-*/
-declare const getPreciseType:(value:unknown,options?:GetPreciseTypeOptions)=>string;type IsNumberOptions={
-/**
-* If set to `true`, `NaN` will be considered a valid number.
-* @default false
-*/
-includeNaN?:boolean;};
-/** ---------------------------------------------------------
-* * ***Type guard: `isNumber`.***
-* ----------------------------------------------------------
-* @description Checks if a value is of type **`number`**.
-*
-* - Uses `typeof value === "number"`.
-* - By default, excludes **`NaN`**.
-* - If `options.includeNaN` is `true`, then **`NaN`** is also considered valid.
-* - Still considers `Infinity` and `-Infinity` as numbers (consistent with JavaScript).
-*
-* ℹ️ To exclude `Infinity` and `-Infinity`, use **{@link isFinite}** instead.
-*
-* @param {*} value - The value to check.
-* @param {IsNumberOptions} options - Optional settings.
-* @param {boolean} options.includeNaN  If `true`, `NaN` will be considered a valid number, dsefaults to `false`, which excludes `NaN`.
-* @returns {boolean} Returns `true` if the value is a number (and depending on `includeNaN`, `NaN` is included or excluded).
-*
-* @example
-* isNumber(42);
-* // ➔ true
-* isNumber(Infinity);
-* // ➔ true
-* isNumber(-Infinity);
-* // ➔ true
-* isNumber(NaN);
-* // ➔ false (default)
-* isNumber(NaN, { includeNaN: true });
-* // ➔ true
-* isNumber("42");
-* // ➔ false
-*/
-declare const isNumber:(value:unknown,options?:IsNumberOptions)=>value is number;type HasKeys<T>=keyof T extends never?false:true;
-/** ----------------------------------------------------------
-* * ***Utility type: `IsPlainObjectResult`.***
-* ----------------------------------------------------------
-* @description
-* Represents the inferred type after asserting a value is a **plain object**.
-*
-
-*
-* - If `T` is `unknown`, the resulting type is `Record<PropertyKey, unknown> & T`.
-* - If `T` is an object:
-*    - If it is a non-plain object (class instance, built-in object, etc.), the result is `never`.
-*    - If it has no keys (`HasKeys<T>` checked by **{@link HasKeys}** is false), the result is `Record<PropertyKey, unknown> & T`.
-*    - Otherwise, the result is `T` itself.
-* - For any other types, the result is `never`.
-*
-* @template T - The input type to be asserted as a plain object.
-* @example
-* ```ts
-* type A = IsPlainObjectResult<unknown>;
-* // ➔ Record<PropertyKey, unknown> & unknown
-* type B = IsPlainObjectResult<{}>;
-* // ➔ Record<PropertyKey, unknown> & {}
-* type C = IsPlainObjectResult<{ foo: string }>;
-* // ➔ { foo: string }
-* type D = IsPlainObjectResult<Date>;
-* // ➔ never
-* ```
-*/
-type IsPlainObjectResult<T>=unknown extends T?Record<PropertyKey,unknown>& T:T extends object?T extends NonPlainObject?never:HasKeys<T>extends false?Record<PropertyKey,unknown>& T:T:Extract<T,Record<PropertyKey,unknown>>;
-/** ----------------------------------------------------------
-* * ***Type guard: `isPlainObject`.***
-* ----------------------------------------------------------
-* @description
-* Checks if a value is a **plain-object**.
-*
-* A plain object is:
-* - Created by the `Object` constructor, or
-* - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).
-* ----------------------------------------------------------
-* - ✅ Returns `true` for:
-*    - Empty object literals: `{}`
-*    - Objects with null prototype: `Object.create(null)`
-* ----------------------------------------------------------
-* - ❌ Returns `false` for:
-*    - Arrays (`[]`, `new Array()`)
-*    - Functions (regular, arrow, or class constructors)
-*    - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`
-*    - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`
-*    - `null` or `undefined`
-*    - Symbols
-*    - Class instances
-*
-* @template T - The type of the value being checked.
-* @param {*} value - The value to check.
-* @returns {boolean} Return `true` if `value` is a `plain-object`, otherwise `false`.
-*
-* @example
-* isPlainObject({});
-* // ➔ true
-* isPlainObject(Object.create(null));
-* // ➔ true
-* isPlainObject(null);
-* // ➔ false
-* isPlainObject(() => {});
-* // ➔ false
-* isPlainObject([1, 2, 3]);
-* // ➔ false
-* isPlainObject(new Date());
-* // ➔ false
-* isPlainObject(new MyClass());
-* // ➔ false
-* isPlainObject(new String("x"));
-* // ➔ false
-*/
-declare function isPlainObject<T>(value:T):value is IsPlainObjectResult<T>;declare function isPlainObject<T>(value:T):value is NonNullable<Extract<T,Record<PropertyKey,unknown>>>;export{type GetPreciseTypeOptions as G,type IsNumberOptions as I,type IsPlainObjectResult as a,isPlainObject as b,getPreciseType as g,isNumber as i};

package/dist/stylings/index.cjs

@@ -1 +0,0 @@
-'use strict';var chunkMY7BA4GI_cjs=require('../chunk-MY7BA4GI.cjs');require('../chunk-62HX5Z45.cjs'),require('../chunk-CN53M4QZ.cjs');Object.defineProperty(exports,"shouldForwardProp",{enumerable:true,get:function(){return chunkMY7BA4GI_cjs.a}});

package/dist/stylings/index.d.ts

@@ -1,49 +0,0 @@
-/**
-* Converts a union type into an intersection type.
-*
-* @template U - The union type to be converted.
-*/
-type UnionToIntersectionStrict<U>=(U extends never?never:(arg:U)=>never)extends(arg:infer I)=>void?I:never;
-/**
-* Converts a union type into a tuple type.
-*
-* @template T - The union type to be converted.
-*/
-type UnionToTupleStrict<T>=UnionToIntersectionStrict<T extends never?never:(t:T)=>T>extends(_:never)=>infer W?[...UnionToTupleStrict<Exclude<T,W>>,W]:[];
-/** ----------------------------------------------------------
-* * ***Creates a helper for styled-components `shouldForwardProp`.***
-* ----------------------------------------------------------
-*
-* @description
-* This utility returns a predicate function that determines
-* whether a given prop should be forwarded to the DOM.
-* Useful for filtering out internal props (e.g., `$size`, `$active`)
-* so they don't end up as invalid HTML attributes.
-*
-* - Accepts a tuple (strict) of prop keys to exclude from forwarding.
-* - Automatically coerces prop names to string for consistent checking.
-* - Supports string, number, or symbol keys (via PropertyKey).
-* - Will throw an error if the provided `props` argument is not an array.
-*
-* @template CustomProps - The type of the component's props.
-* @param {UnionToTupleStrict<keyof CustomProps>} props
-*   The list of prop names (keys of `CustomProps`) to exclude from forwarding.
-*
-* @returns {(propName: PropertyKey) => boolean}
-*   A function that takes a prop name and returns `true` if it should be forwarded, `false` if it should be blocked.
-*
-* @throws {Error} If `props` is not an array.
-*
-* @example
-* type Props = { $size: string; color: string; visible: boolean };
-* const filter = shouldForwardProp<Props>(["$size"]);
-* filter("$size"); // false (blocked)
-* filter("color"); // true (forwarded)
-*
-* @example
-* // Using with styled-components:
-* styled.div.withConfig({
-*   shouldForwardProp: shouldForwardProp<CustomProps>(["$internal"])
-* })
-*/
-declare const shouldForwardProp:<CustomProps>(props:Partial<UnionToTupleStrict<keyof CustomProps>>)=>((propName:keyof CustomProps)=>boolean);export{shouldForwardProp};

package/dist/stylings/index.js

@@ -1 +0,0 @@
-export{a as shouldForwardProp}from'../chunk-FF76ISQ2.js';import'../chunk-QFCGBBSY.js';import'../chunk-XCFIOTCV.js';