@rzl-zone/utils-js 2.1.0 → 3.0.0

package/dist/isPlainObject-BVhBAPHX.d.ts

@@ -0,0 +1,169 @@
+import{N as NonPlainObject}from'./type-data-DDs-u2kq.js';
+/** Types for **{@link getPreciseType}**. */
+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";};
+/** ----------------------------------------------------------
+ * * ***Utility-Predicate: `getPreciseType`.***
+ * ----------------------------------------------------------
+ * **Returns a detailed and normalized type string for the given value.**
+ * @description
+ * 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 {GetPreciseTypeOptions} [options] - Optional configuration
+ * @param {GetPreciseTypeOptions["formatCase"]} [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, defaultValue: `false`.
+ *
+ * @default false
+ */
+includeNaN?:boolean;};
+/** ---------------------------------------------------------
+ * * ***Type guard: `isNumber`.***
+ * ----------------------------------------------------------
+ * **Checks if a value is of type **`number`**.**
+ * - **Behavior:**
+ *    - 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).
+ * - **ℹ️ Note:**
+ *    - To exclude `Infinity` and `-Infinity`, use **{@link isFinite | `isFinite`}** instead.
+ * @param {*} value - The value to check.
+ * @param {IsNumberOptions} [options] - Optional settings.
+ * @param {boolean} [options.includeNaN=false]  If `true`, `NaN` will be considered a valid number, defaults 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`.***
+ * ----------------------------------------------------------
+ * **Represents the inferred type after asserting a value is a **plain object**.**
+ * - **Behavior:**
+ *    - 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`.***
+ * ----------------------------------------------------------
+ * **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/never-BfayMBF9.d.ts

@@ -0,0 +1,75 @@
+import{I as If}from'./if-CvT4R7Kh.js';
+/** -------------------------------------------------------
+ * * ***IsNever.***
+ * -------------------------------------------------------
+ * **Conditional**: returns `true` if `T` is `never`, otherwise `false`.
+ *
+ * @template T - Type to check.
+ * @example
+ * ```ts
+ * type A = IsNever<never>; // ➔ true
+ * type B = IsNever<true>;  // ➔ false
+ * ```
+ */
+type IsNever<T>=[T] extends [never]?true:false;
+/** -------------------------------------------------------
+ * * ***IfNever.***
+ * -------------------------------------------------------
+ * **Conditional**: Selects one of two branches depending on whether `T` is `never`.
+ * - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *
+ * @template T - Type to check.
+ * @template IfTrue - The branch type if `T` is `never`, (default: `true`).
+ * @template IfFalse - The branch type if `T` is not `never`, (default: `false`).
+ * @example
+ * ```ts
+ * type A = IfNever<never>;
+ * // ➔ true
+ * type B = IfNever<string>;
+ * // ➔ false
+ * type C = IfNever<never, 'valid', 'no'>;
+ * // ➔ 'valid'
+ * type D = IfNever<string, 'valid', 'no'>;
+ * // ➔ 'no'
+ * ```
+ */
+type IfNever<T,IfTrue=true,IfFalse=false>=If<IsNever<T>,IfTrue,IfFalse>;
+/** -------------------------------------------------------
+ * * ***NeverifyPropertiesOptions.***
+ * -------------------------------------------------------
+ * Configuration options for the ***{@link NeverifyProperties}*** type utility.
+ *
+ * @property makeOptional - Whether to make all properties optional.
+ *   - If `true`, resulting properties will be optional (`?`).
+ *   - Default: `false`.
+ *
+ * @example
+ * ```ts
+ * type Opt1 = NeverifyPropertiesOptions;
+ * // ➔ { makeOptional: boolean }
+ * ```
+ */
+type NeverifyPropertiesOptions={
+/** Whether to make all properties optional, defaultValue: `false`.
+ *
+ * @default false
+ */
+makeOptional:boolean;};
+/** -------------------------------------------------------
+ * * ***NeverifyProperties.***
+ * -------------------------------------------------------
+ * Turns all properties of an object to type `never`.
+ * - If `Options["makeOptional"]` is `true`, properties will be optional.
+ *
+ * @template T - Object type to transform.
+ * @template Options - Configuration options (default: `{ makeOptional: false }`).
+ * @example
+ * ```ts
+ * type A = NeverifyProperties<{ a: string; b: string }>;
+ * // ➔ { a: never; b: never }
+ *
+ * type B = NeverifyProperties<{ a: string; b: string }, { makeOptional: true }>;
+ * // ➔ { a?: never; b?: never }
+ * ```
+ */
+type NeverifyProperties<T extends object,Options extends NeverifyPropertiesOptions={makeOptional:false;}>={[K in keyof T]:never;}extends infer Result?If<Options["makeOptional"],Partial<Result>,Result>:never;export type{IsNever as I,NeverifyProperties as N,IfNever as a,NeverifyPropertiesOptions as b};

package/dist/next/index.cjs

@@ -1 +1 @@
-'use strict';function E(r){return Array.isArray(r)}var o=r=>typeof r=="string";var h=(r,e)=>{if(!o(r))return true;s(e)||(e={});let{trim:n=true}=e;return n&&(r=r.trim()),r===""};var d=r=>typeof r=="boolean";var $=r=>r instanceof Error;function T(r){return Array.isArray(r)&&r.length>0}function s(r){return typeof r=="object"&&!v(r)&&!E(r)}var p=(r,e)=>{if(!o(r))return false;s(e)||(e={});let{trim:n=true}=e;return(n?r.trim():r).length>0};var u=r=>typeof r>"u";function v(r){return r==null}var c=(r,e={trimOnly:false})=>{if(!p(r))return "";s(e)||(e={});let{trimOnly:n=false}=e;return n?r.trim():r.replace(/\s+/g,"")};var w=(r,e="/")=>{if(!p(e))throw new TypeError(`Invalid parameter:'defaultPath' must be a string and string is non-empty string. Received:${typeof e}(${e})`);if(!p(r))return e;try{if(r=c(r,{trimOnly:!0}),r=r.replace(/\s+/g,""),r.startsWith("http://")||r.startsWith("https://")){let n=new URL(r);return `${n.pathname}${n.search}${n.hash}`.replace(/^\/+/,"/")}return "/"+r.replace(/^\/+/,"").replace(/\/{2,}/g,"/")}catch(n){let t=$(n)?n:new Error("Unknown error from function `normalizePathname()`");throw new x(`Failed to normalize pathname in function \`normalizePathname()\`:${t.message}`,t)}};var y=(r,e)=>{if(!p(r))return "";if(!u(e)){if(!s(e))throw new TypeError("Options must be an object.");if("prefixColon"in e&&!d(e.prefixColon))throw new TypeError("Option `prefixColon` must be a boolean.")}let n=r.replace(/\D+/g,"");return n?e?.prefixColon??false?`:${n}`:n:""};var x=class r extends Error{constructor(n,t){super(n);this.originalError=t;this.name="NormalizePathnameError",Error.captureStackTrace&&Error.captureStackTrace(this,r);}};function G(r,e){if(!o(r)||h(r))throw new TypeError(`\u{1F6A8}'generateRoute' Failed:- Invalid 'route' value.- Expected a non-empty string,but received ${typeof r}:${JSON.stringify(r)}`);if(!r.includes("["))return r;if(!s(e))throw new Error(`\u{1F6A8}'generateRoute' Failed cause in route "${r}":- Missing or invalid parameters object for route:"${r}",expected an object mapping parameters.`);if(!e)throw new Error(`\u{1F6A8}'generateRoute' Failed cause in route "${r}":- Missing parameters object for route:"${r}"`);let n=["?","&","#","=","/"," ","'",'"',"(",")","+",";","%","@",":"],t=[],i=Array.from(r.matchAll(/\[(\w+)\]/g)).map(a=>a[1]);for(let a of i){let l=e[a];if(u(l)){t.push(`- Missing parameter:"${a}".`);continue}let f=l.trim();if(!f){t.push(`- Parameter "${a}" cannot be empty.`);continue}f.includes("/")&&t.push(`- Parameter "${a}" contains slashes "/" which is not allowed.`);let g=n.filter(m=>m!=="/").filter(m=>f.includes(m));g.length>0&&t.push(`- Parameter "${a}" contains invalid characters(${g.length>1?g.join(","):g}). These characters are not allowed because they could cause issues in URL structure. The following characters are forbidden in route parameters:(${n.join(",")}).`);}if(T(t))throw new Error(`\u{1F6A8}'generateRoute' Failed cause in route "${r}":${t.join(``)}`);return r.replace(/\[(\w+)\]/g,(a,l)=>e[l].trim().replace(/^\/+|\/+$/g,"")).replace(/\/+/g,"/")}var rr=(r="",e)=>{try{let f=function(m,P){return `${m.replace(/\/+$/,"")}/${P.replace(/^\/+/,"")}`};var n=f;if(!o(r))throw new TypeError(`Invalid type for 'pathname'. Expected 'string',received:${typeof r}`);s(e)||(e={});let{prefix:t="/api",withOrigin:i=!0}=e;if(!u(t)&&!o(t))throw new TypeError(`Invalid type for 'prefix'. Expected 'string',received:${typeof t}`);if(!d(i))throw new TypeError(`Invalid type for 'withOrigin'. Expected 'boolean',received:${typeof i}`);r=w(r),t=w(t);let a=t.endsWith("/")?t:t+"/";(r===t||r===t+"/"||r.startsWith(a))&&(r=r.slice(t.length),r=w(r));let l=b({suffix:t});return f(i?l:new URL(l).pathname,r).replace(/\/+$/,"")}catch(t){throw new Error("Failed to generate backend API URL in `createBeApiUrl()`,Error:"+t)}};var b=({suffix:r="/"}={})=>{if(!o(r))throw new TypeError(`Invalid type for 'suffix'. Expected string,received:${typeof r}`);try{let e=process.env.NEXT_PUBLIC_BACKEND_API_URL?.trim();if(e){e=c(e);let i=new URL(e);!!!i.port&&process.env.NEXT_PUBLIC_PORT_BE&&(e=i.origin+y(process.env.NEXT_PUBLIC_PORT_BE,{prefixColon:!0}));}else e="http://localhost"+y(process.env.NEXT_PUBLIC_PORT_BE||"8000",{prefixColon:!0});r=c(r).length?c(r):"/";let n=new URL(e.replace(/\/+$/,"")).origin,t=r==="/"?"/":`${r.startsWith("/")?"":"/"}${r.replace(/\/+$/,"")}`;return `${n}${t}`}catch(e){throw new Error("Invalid `NEXT_PUBLIC_BACKEND_API_URL`,failed to generate from `getBeApiUrl()`,Error:"+e)}};var or=()=>{try{let r=process.env.NEXT_PUBLIC_BASE_URL?.trim(),e=process.env.NEXT_PUBLIC_PORT_FE?.trim(),n=r||"http://localhost";n=c(n).replace(/\/+$/,"");let t=/:\/\/[^/]+:\d+/.test(n);!t&&e?n+=y(e,{prefixColon:!0}):!t&&!r&&(n+=":3000");let i=new URL(n);return `${i.protocol}//${i.hostname}${i.port?`:${i.port}`:""}`}catch(r){throw new Error("Invalid `NEXT_PUBLIC_BASE_URL`,failed to generate from `getBaseUrl()`,Error:"+r)}};exports.createBeApiUrl=rr;exports.generateRoute=G;exports.getBaseUrl=or;exports.getBeApiUrl=b;
+"use strict";var e=require("../chunk-SBF43G3B.cjs"),r=require("../chunk-2HSNUPEO.cjs"),t=require("../chunk-4Z75R3IT.cjs"),n=require("../chunk-VCFXNV3Q.cjs");require("../chunk-DVMHRLKP.cjs");var s=require("../chunk-ZHV5ZYVN.cjs");require("../chunk-UDA26MCU.cjs");var i=require("../chunk-D3VSHABU.cjs");var a=({suffix:t="/"}={})=>{var s;n.assertIsString(t,{message:({currentType:e,validType:r})=>`Parameter \`suffix\` property of the first parameter must be of type \`${r}\`, but received: \`${e}\`.`});try{let n=null==(s=process.env.NEXT_PUBLIC_BACKEND_API_URL)?void 0:s.trim();if(n){n=r.removeSpaces(n);const t=new URL(n);!!!t.port&&process.env.NEXT_PUBLIC_PORT_BE&&(n=t.origin+e.formatEnvPort(process.env.NEXT_PUBLIC_PORT_BE,{prefixColon:!0}))}else n="http://localhost"+e.formatEnvPort(process.env.NEXT_PUBLIC_PORT_BE||"8000",{prefixColon:!0});t=r.removeSpaces(t).length?r.removeSpaces(t):"/";const i=new URL(n.replace(/\/+$/,"")).origin;return`${i}${"/"===t?"/":`${t.startsWith("/")?"":"/"}${t.replace(/\/+$/,"")}`}`}catch(e){throw new Error("Invalid `NEXT_PUBLIC_BACKEND_API_URL`, failed to generate from `getBeApiUrl()`, Error:"+e)}};exports.createBeApiUrl=(r,t={})=>{try{let s=function(e,r){return`${e.replace(/\/+$/,"")}/${r.replace(/^\/+/,"")}`};n.assertIsString(i.isNil(r)?"":r,{message:({currentType:e,validType:r})=>`First parameter (\`pathname\`) must be of type \`${r}\`, but received: \`${e}\`.`}),i.isPlainObject(t)||(t={});let{prefix:o="/api",withOrigin:c=!0}=t;if(!i.isUndefined(o)&&!i.isString(o))throw new TypeError(`Parameter \`prefix\` property of the \`options\` (second parameter) must be of type \`string\`, but received: \`${i.getPreciseType(o)}\`.`);i.assertIsBoolean(c,{message:({currentType:e,validType:r})=>`Parameter \`withOrigin\` property of the \`options\` (second parameter) must be of type \`${r}\`, but received: \`${e}\`.`}),r=e.normalizePathname(r),o=e.normalizePathname(o);const p=o.endsWith("/")?o:o+"/";(r===o||r===o+"/"||r.startsWith(p))&&(r=r.slice(o.length),r=e.normalizePathname(r));const u=a({suffix:o});return s(c?u:new URL(u).pathname,r).replace(/\/+$/,"")}catch(e){throw i.isError(e)?e:new Error("Failed to generate backend API URL in `createBeApiUrl()`, Error: "+new Error(String(e)).message.trim())}},exports.generateRoute=function(e,r){if(!i.isString(e)||t.isEmptyString(e))throw new TypeError(`❌ 'generateRoute' Failed:\n- Invalid 'route' value.\n- Must be of type \`string\` and non-empty string, but received: "${i.getPreciseType(e)}": \`${s.safeStableStringify(e)}\`.`);if(!/[\\[\]]/.test(e))return e;if(i.assertIsPlainObject(r,{message:({validType:r})=>`❌ 'generateRoute' Failed cause in route "${e}":\n- Missing or invalid parameters \`${r}\` for route: "${e}", must be of type \`${r}\` mapping parameters.`}),i.isNil(r))throw new TypeError(`❌ 'generateRoute' Failed cause in route "${e}":\n- Missing parameters \`plain-object\` for route: "${e}".`);const n=["?","&","#","=","/","'",'"',"(",")","+",";","%","@",":"],a=[],o=Array.from(e.matchAll(/\[(\w+)\]/g)).map(e=>e[1]);for(const e of o){const s=r[e];if(!i.isString(s)){a.push(`- Invalid parameter: "${e}" must be of type \`string\`, but received: \`${i.getPreciseType(s)}\`.`);continue}if(t.isEmptyString(s)){a.push(`- Parameter "${e}" cannot be empty string.`);continue}const o=n.filter(e=>s.includes(e));if(/\s/.test(s)&&o.push("white-space(s)"),o.length>0){const r=o.map(e=>"`"===e?"backtick - (`)":`\`${e}\``);n.includes("white-space(s)")||n.push("white-space(s)");const t=n.map(e=>"`"===e?"backtick - (`)":`\`${e}\``);a.push(`- Parameter "${e}" contains invalid characters (${r.join(", ")}). These characters are not allowed because they could cause issues in URL structure. The following characters are forbidden in route parameters: (${t.join(", ")}).`)}}if(i.isNonEmptyArray(a))throw new Error(`❌ 'generateRoute' Failed cause in route "${e}":\n${a.join("\n")}.`);return e.replace(/\[(\w+)\]/g,(e,t)=>(i.isNonEmptyString(r[t])?r[t]:"").trim().replace(/^\/+|\/+$/g,"")).replace(/\/+/g,"/")},exports.getBaseUrl=()=>{var t,n;try{const s=null==(t=process.env.NEXT_PUBLIC_BASE_URL)?void 0:t.trim(),i=null==(n=process.env.NEXT_PUBLIC_PORT_FE)?void 0:n.trim();let a=s||"http://localhost";a=r.removeSpaces(a).replace(/\/+$/,"");const o=/:\/\/[^/]+:\d+/.test(a);!o&&i?a+=e.formatEnvPort(i,{prefixColon:!0}):o||s||(a+=":3000");const c=new URL(a);return`${c.protocol}//${c.hostname}${c.port?`:${c.port}`:""}`}catch(e){throw new Error("Invalid `NEXT_PUBLIC_BASE_URL`, failed to generate from `getBaseUrl()`, Error:"+e)}},exports.getBeApiUrl=a;

package/dist/next/index.d.ts

@@ -1,184 +1,204 @@
-
-/** Extracts dynamic route parameters from a given route string.
- *
- * This utility type recursively searches for dynamic segments within a route,
+import{I as IsAny}from'../any-BmdI8UbK.js';import'../if-CvT4R7Kh.js';
+/** ---------------------------------------------------------
+ * * ***Extracts dynamic route parameters from a given route string.***
+ * ---------------------------------------------------------
+ * **This utility type recursively searches for dynamic segments within a route,
  * extracting each parameter and constructing an object where each key represents
- * a dynamic segment and its value is of type `string`.
- *
- * * ⚠️ ***Notes: This Type only support when using `NextJS`***
- *
+ * a dynamic segment and its value is of type `string`.**
+ * - ***⚠️ Warning:***
+ *    - ***This types only support when using ***[`NextJS`](https://nextjs.org/)***.***
  * @template T - The route string containing potential dynamic segments.
- *
  * @example
  * ```ts
  * type Params1 = ExtractRouteParams<"/user/[id]">;
- * // Result: { id: string }
- *
+ * // ➔ { id: string }
  * type Params2 = ExtractRouteParams<"/post/[slug]/comment/[commentId]">;
- * // Result: { slug: string; commentId: string }
- *
+ * // ➔ { slug: string; commentId: string }
  * type Params3 = ExtractRouteParams<"/dashboard">;
- * // Result: {} (no dynamic parameters)
+ * // ➔ {} (no dynamic parameters)
  * ```
  */
-type ExtractRouteParams<T extends string>=T extends `${infer _Start}[${infer Param}]${infer Rest}` ?{[K in Param]:string;}& ExtractRouteParams<Rest>:Record<any,any>;
-/** Determines whether a given route contains dynamic segments.
- *
- * This type checks if the route includes at least one `[param]` pattern.
- * If it does, the result is `true`, otherwise `false`.
- *
- * * ⚠️ ***Notes: This Type only support when using `NextJS`***
- *
+type ExtractRouteParams<T>=T extends string?HasDynamicSegments<T>extends true?T extends`${infer _Start}[${infer Param}]${infer Rest}`?{[K in Param|keyof ExtractRouteParams<Rest>]:string;}:unknown:unknown:unknown;
+/** ---------------------------------------------------------
+ * * ***Determines whether a given route contains dynamic segments.***
+ * ---------------------------------------------------------
+ * **This type checks if the route includes at least one `[param]` pattern.
+ * If it does, the result is `true`, otherwise `false`.**
+ * - ***⚠️ Warning:***
+ *    - ***This types only support when using ***[`NextJS`](https://nextjs.org/)***.***
  * @template T - The route string to be evaluated.
- *
  * @example
  * ```ts
  * type HasParams1 = HasDynamicSegments<"/user/[id]">;
- * // Result: true
- *
+ * // ➔ true
  * type HasParams2 = HasDynamicSegments<"/settings/profile">;
- * // Result: false
- *
+ * // ➔ false
  * type HasParams3 = HasDynamicSegments<"/blog/[category]/[slug]">;
- * // Result: true
+ * // ➔ true
  * ```
  */
-type HasDynamicSegments<T extends string>=T extends `${string}[${string}]${string}` ? true:false;
+type HasDynamicSegments<T>=T extends`${string}[${string}]${string}`?true:false;type GenerateRouteResult<T>=true extends IsAny<T>?unknown:T extends string?string:unknown;
 /** ---------------------------------
  * * ***Generates a URL by replacing dynamic route parameters with provided values.***
  * ---------------------------------
- *
- * * ⚠️ ***Notes: This Function only support when using `NextJS`***
- *
+ * - ***⚠️ Warning:***
+ *    - ***This function only support when using ***[`NextJS`](https://nextjs.org/)***.***
  * @template T - The route string containing dynamic segments in the format `[param]`.
- *
  * @param {T} route - The route string containing dynamic segments.
  * @param {ExtractRouteParams<T>} [params] - An object containing key-value pairs that match the dynamic segments in the route.
- *
  * @returns {string} The formatted URL with all dynamic segments replaced.
- *
  * @throws {Error} If the route contains dynamic segments but no parameters object is provided.
  * @throws {Error} If a required parameter is missing from the `params` object.
  * @throws {Error} If a parameter value is an empty string.
  * @throws {Error} If any parameter contains invalid characters like `?`, `&`, `=`, `#`, `/`, spaces, `'`, `"`, `(`, `)`, `+`, `;`, `%`, `@`, or `:`, which can cause URL issues.
- *
  * @example
  * // Basic usage
  * generateRoute("/user/[id]", { id: "123" });
- * // Returns: "/user/123"
+ * // ➔ "/user/123"
  *
- * @example
  * // No dynamic segments, returns as-is
  * generateRoute("/dashboard");
- * // Returns: "/dashboard"
+ * // ➔ "/dashboard"
  *
- * @example
  * // Throws an error due to missing parameters object
  * generateRoute("/profile/[username]");
- * // ❌ Error: 🚨 Missing parameters object for route: "/profile/[username]"
+ * // ➔ ❌ Error: ❌ Missing parameters object for route: "/profile/[username]"
  *
- * @example
  * // Throws an error due to an empty parameter value
  * generateRoute("/post/[category]/[slug]", { category: "tech", slug: "" });
- * // ❌ Error: 🚨 Parameter "slug" cannot be empty in route: "/post/[category]/[slug]"
+ * // ➔ ❌ Error: ❌ Parameter "slug" cannot be empty in route: "/post/[category]/[slug]"
  *
- * @example
  * // Throws an error due to parameter containing invalid characters
  * generateRoute("/search/[query]", { query: "how to?learn" });
- * // ❌ Error: 🚨 Parameter "query" contains invalid character "?" in route: "/search/[query]"
+ * // ➔ ❌ Error: ❌ Parameter "query" contains invalid character "?" in route: "/search/[query]"
  *
- * @example
  * // Handles leading/trailing slashes correctly
  * generateRoute("/blog/[category]/[slug]", { category: "/news/", slug: "/latest-update/" });
- * // ❌ Error: 🚨 Parameter "category" and "slug" contains slashes "/" which is not allowed.
+ * // ➔ ❌ Error: ❌ Parameter "category" and "slug" contains slashes "/" which is not allowed.
  */
-declare function generateRoute<T extends string>(route:T,...params:HasDynamicSegments<T>extends true ? [ExtractRouteParams<T>]:[]):string;
+declare function generateRoute<T extends string>(route:T extends string?(HasDynamicSegments<T>extends true?T:never):never,params:T extends string?ExtractRouteParams<T>:undefined):GenerateRouteResult<T>;declare function generateRoute<T extends string>(route:T extends string?T:never,params?:Extract<ExtractRouteParams<T>,Record<string,unknown>>):GenerateRouteResult<T>;declare function generateRoute<T=unknown>(route:T extends string?(HasDynamicSegments<T>extends true?T:unknown):unknown,params?:T extends string?ExtractRouteParams<T>:undefined):unknown;type OptionsCreateBeApiUrl={
+/** * The prefix pathname api url, e.g:`"http://localhost.com/your-target-prefix-entri-point-api-is-here"`, default: `"/api"`.
+ *
+ * @default "/api" */
+prefix?:string;
+/** * Option to getting `prefix` and `pathname` of api url only `(removing origin base api url)`, default: `true`.
+ *
+ * @default true */
+withOrigin?:boolean;};
 /** ---------------------------------
  * * ***Constructs a backend API URL by appending a given pathname to the base API URL.***
  * ---------------------------------
- * This function builds on top of `getBeApiUrl()`, which determines the base API URL from:
- * - `NEXT_PUBLIC_BACKEND_API_URL` environment variable (or defaults to `"http://localhost:8000"`).
- * - Automatically appends `NEXT_PUBLIC_PORT_BE` if the base URL does not already include a port.
- *
- * Features of this function:
- * - Allows customizing the API path with an optional `prefix` (defaults to `"/api"`).
- * - Can include or exclude the origin (protocol + host) via `withOrigin`.
- * - Normalizes paths to avoid duplicate slashes.
- *
- * * ⚠️ ***Notes: This Function only support when using `NextJS`***
- *
- * @param {string} pathname - The API endpoint path (e.g., `/users` or `/v1/posts`).
- * @param {Object} options - Configuration options.
- * @param {string} [options.prefix="/api"] - The prefix for the API path (default is `"/api"`).
- * @param {boolean} [options.withOrigin=true] - Whether to include the full base URL or return only the API path.
+ * This function builds on top of `getBeApiUrl()`.
+ * - **Determines the base API URL from:**
+ *    - `NEXT_PUBLIC_BACKEND_API_URL` environment variable (or defaults to `"http://localhost:8000"`).
+ *    - Automatically appends `NEXT_PUBLIC_PORT_BE` if the base URL does not already include a port.
+ * - **Features of this function:**
+ *    - Allows customizing the API path with an optional `prefix` (defaults to `"/api"`).
+ *    - Can include or exclude the origin (protocol + host) via `withOrigin`.
+ *    - Normalizes paths to avoid duplicate slashes.
+ * - ***⚠️ Warning:***
+ *    - ***This function only support when using ***[`NextJS`](https://nextjs.org/)***.***
+ * @param {string|null|undefined} pathname - The API endpoint path (e.g., `/users` or `/v1/posts`), defaultValue: `""`.
+ * @param {OptionsCreateBeApiUrl} [options] - Configuration options.
+ * @param {OptionsCreateBeApiUrl["prefix"]} [options.prefix="/api"] - The prefix for the API path (default is `"/api"`).
+ * @param {OptionsCreateBeApiUrl["withOrigin"]} [options.withOrigin=true] - Whether to include the full base URL or return only the API path.
  * @returns {string} The formatted API URL.
- *
  * @throws {TypeError} If `withOrigin` is not a boolean.
  * @throws {TypeError} If `prefix` and `pathname` is not a string.
  * @throws {Error} If constructing the API URL fails due to an invalid base URL.
- *
  * @example
  * createBeApiUrl("/users")
- * // -> "http://localhost:8000/api/users"
- *
+ * // ➔ "http://localhost:8000/api/users"
+ * createBeApiUrl("/api/users")
+ * // ➔ "http://localhost:8000/api/users"
+ * createBeApiUrl("/v1", { prefix: "/v1" })
+ * // ➔ "http://localhost:8000/v1"
+ * createBeApiUrl("/v1/users")
+ * // ➔ "http://localhost:8000/api/v1/users"
+ * createBeApiUrl("/v1/users", { prefix: "/v1" })
+ * // ➔ "http://localhost:8000/v1/users"
  * createBeApiUrl("/users", { withOrigin: false })
- * // -> "/api/users"
+ * // ➔ "/api/users"
+ * createBeApiUrl(null, { withOrigin: false })
+ * // ➔ "/api"
+ * createBeApiUrl(undefined, { withOrigin: false })
+ * // ➔ "/api"
  */
 declare const createBeApiUrl:(
 /** * The pathname api url, e.g:`"http://localhost.com/your-target-prefix-entri-point-api-is-here/your-target-pathname-is-here"`.
  *
- * @default "" */
-pathname?:string,options?:{
-/** * The prefix pathname api url, e.g:`"http://localhost.com/your-target-prefix-entri-point-api-is-here"`.
-	 *
-	 * @default "/api" */
-prefix?:string;
-/** * Option to getting `prefix` and `pathname` of api url only `(removing origin base api url)`.
-	 *
-	 * @default true */
-withOrigin?:boolean;})=>string;
-/** ---------------------------------
- * * ***Retrieves the base API URL of the backend.***
- * ---------------------------------
- *
- * This function determines the backend API base URL from the `NEXT_PUBLIC_BACKEND_API_URL` environment variable.
- * If the variable is not set, it defaults to `"http://localhost:8000"`.
- * It also allows adding an optional suffix to the returned URL.
- *
- * * ⚠️ ***Notes: This Function only support when using `NextJS`***
+ * @default ""
+ */
+pathname:string|null|undefined,options?:OptionsCreateBeApiUrl)=>string;type OptionsGetBeApiUrl={
+/** * The Suffix origin base api url, e.g:`http://localhost.com/api`, default: `"/"`.
  *
+ * @default "/" */
+suffix?:string;};
+/** ---------------------------------------------------
+ * * ***Retrieves the base API URL of the backend.***
+ * ---------------------------------------------------
+ * **This function determines the backend API base URL from the `NEXT_PUBLIC_BACKEND_API_URL` environment variable.**
+ * - **Behavior:**
+ *    - If the variable is not set, it defaults to `"http://localhost:8000"`.
+ *    - It also allows adding an optional suffix to the returned URL.
+ * - ***⚠️ Warning:***
+ *    - ***This function only support when using ***[`NextJS`](https://nextjs.org/)***.***
+ * @description
  * This function determines the backend API base URL from the `NEXT_PUBLIC_BACKEND_API_URL` environment variable.
  * - If `NEXT_PUBLIC_BACKEND_API_URL` is not set, it defaults to `"http://localhost:8000"`.
  * - If `NEXT_PUBLIC_BACKEND_API_URL` does **not** contain a port, it appends one from `NEXT_PUBLIC_PORT_BE` if available.
  * - Supports appending optional suffix (like "/api").
- *
- *
- * @param {Object} options - Configuration options.
- * @param {string} [options.suffix="/"] - The suffix to append to the base API URL.
+ * @param {OptionsGetBeApiUrl|undefined} options - Configuration options.
+ * @param {OptionsGetBeApiUrl["suffix"]} [options.suffix="/"] - The suffix to append to the base API URL.
  * @returns {string} The formatted backend API base URL.
  * @throws {TypeError} If `suffix` is not a `string`.
  * @throws {Error} If `NEXT_PUBLIC_BACKEND_API_URL` is invalid.
+ * @example
+ * // With NEXT_PUBLIC_BACKEND_API_URL set at `*.env` file
+ * NEXT_PUBLIC_BACKEND_API_URL = "https://api.example.com";
+ * getBeApiUrl();
+ * // ➔ "https://api.example.com/"
+ *
+ * // With NEXT_PUBLIC_BACKEND_API_URL but no port, using NEXT_PUBLIC_PORT_BE at `*.env` file
+ * NEXT_PUBLIC_BACKEND_API_URL = "http://localhost";
+ * NEXT_PUBLIC_PORT_BE = "5000";
+ * getBeApiUrl({ suffix: "/api" });
+ * // ➔ "http://localhost:5000/api"
+ *
+ * // Without NEXT_PUBLIC_BACKEND_API_URL at `*.env` file (defaults to localhost:8000)
+ * delete NEXT_PUBLIC_BACKEND_API_URL;
+ * getBeApiUrl({ suffix: "/v1" });
+ * // ➔ "http://localhost:8000/v1"
  */
-declare const getBeApiUrl:({suffix,}?:{
-/** * The Suffix origin base api url, e.g:`http://localhost.com/api`.
-	 *
-	 * @default "/" */
-suffix?:string;})=>string;
-/** ---------------------------------
+declare const getBeApiUrl:({suffix}?:OptionsGetBeApiUrl)=>string;
+/** ---------------------------------------------------
  * * ***Retrieves the base URL of the application.***
- * ---------------------------------
- *
- * This function is designed to be used within Next.js applications.
- * It determines the base URL from the `NEXT_PUBLIC_BASE_URL` environment variable.
- *
- * * ⚠️ ***Notes: This Function only support when using `NextJS`***
- *
- * - If `NEXT_PUBLIC_BASE_URL` is not set, it defaults to `"http://localhost:3000"`.
- * - If `NEXT_PUBLIC_BASE_URL` does **not** contain a port, it appends one from `NEXT_PUBLIC_PORT_FE` if available.
- * - Ensures the final URL is valid and normalized (no trailing slashes).
- *
+ * ---------------------------------------------------
+ * **This function is designed to be used within `Next.js` applications.**
+ * - **Behavior:**
+ *    - It determines the base URL from the `NEXT_PUBLIC_BASE_URL` environment variable.
+ *    - If `NEXT_PUBLIC_BASE_URL` is not set, it defaults to `"http://localhost:3000"`.
+ *    - If `NEXT_PUBLIC_BASE_URL` does **not** contain a port, it appends one from `NEXT_PUBLIC_PORT_FE` if available.
+ *    - Ensures the final URL is valid and normalized (no trailing slashes).
+ * - ***⚠️ Warning:***
+ *    - ***This function only support when using ***[`NextJS`](https://nextjs.org/)***.***
  * @returns {string} The resolved base URL of the application.
  * @throws {Error} If the constructed URL is invalid or malformed.
- *
+ * @example
+ * // With environment variable set at `*.env` file
+ * NEXT_PUBLIC_BASE_URL = "https://example.com";
+ * getBaseUrl();
+ * // ➔ "https://example.com"
+ *
+ * // With custom port via NEXT_PUBLIC_PORT_FE  at `*.env` file
+ * NEXT_PUBLIC_BASE_URL = "http://localhost";
+ * NEXT_PUBLIC_PORT_FE = "4000";
+ * getBaseUrl();
+ * // ➔ "http://localhost:4000"
+ *
+ * // Without environment variable at `*.env` file
+ * delete NEXT_PUBLIC_BASE_URL;
+ * getBaseUrl();
+ * // ➔ "http://localhost:3000"
  */
-declare const getBaseUrl:()=>string;export{createBeApiUrl,generateRoute,getBaseUrl,getBeApiUrl};export type{ExtractRouteParams,HasDynamicSegments};
+declare const getBaseUrl:()=>string;export{type ExtractRouteParams,type HasDynamicSegments,createBeApiUrl,generateRoute,getBaseUrl,getBeApiUrl};