@duplojs/utils 1.4.47 → 1.4.49

package/dist/common/path.cjs

@@ -0,0 +1,114 @@
+'use strict';
+
+var success = require('../either/right/success.cjs');
+var fail = require('../either/left/fail.cjs');
+
+exports.Path = void 0;
+(function (Path) {
+    Path.baseNameRegex = /\/?([^/]+)$/;
+    Path.folderNameRegex = /([^]+)\/[^/]+\/?$/;
+    Path.extensionNameRegex = /\.([^./]+)$/;
+    Path.isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+    Path.segmentTrailingRegex = /\/$/;
+    Path.segmentRelativeRegex = /^(.\/)/;
+    /**
+     * {@include common/path/getBaseName/index.md}
+     */
+    function getBaseName(path, params) {
+        const match = Path.baseNameRegex.exec(path);
+        if (!match) {
+            return null;
+        }
+        if (params?.removeExtension) {
+            return match[1].replace(Path.extensionNameRegex, "");
+        }
+        return match[1];
+    }
+    Path.getBaseName = getBaseName;
+    /**
+     * {@include common/path/getExtensionName/index.md}
+     */
+    function getExtensionName(path) {
+        const match = Path.extensionNameRegex.exec(path);
+        if (match) {
+            return match[1];
+        }
+        return null;
+    }
+    Path.getExtensionName = getExtensionName;
+    /**
+     * {@include common/path/getParentFolderPath/index.md}
+     */
+    function getParentFolderPath(path) {
+        const match = path.match(Path.folderNameRegex);
+        if (!match) {
+            return null;
+        }
+        return match[1];
+    }
+    Path.getParentFolderPath = getParentFolderPath;
+    /**
+     * {@include common/path/isAbsolute/index.md}
+     */
+    function isAbsolute(path) {
+        return path.startsWith("/")
+            && !Path.isRelativeRegex.test(path);
+    }
+    Path.isAbsolute = isAbsolute;
+    /**
+     * {@include common/path/resolveFrom/index.md}
+     */
+    function resolveFrom(origin, segments) {
+        const result = resolveRelative([origin, ...segments]);
+        return isAbsolute(result)
+            ? success.success(result)
+            : fail.fail();
+    }
+    Path.resolveFrom = resolveFrom;
+    /**
+     * {@include common/path/resolveRelative/index.md}
+     */
+    function resolveRelative(segments) {
+        let clearedPath = "";
+        for (const segment of segments) {
+            if (segment.length === 0) {
+                continue;
+            }
+            if (segment === "/") {
+                clearedPath = segment;
+                continue;
+            }
+            const formattedSegment = segment
+                .replace(Path.segmentTrailingRegex, "")
+                .replace(Path.segmentRelativeRegex, "");
+            if (formattedSegment.startsWith("/")) {
+                clearedPath = formattedSegment;
+                continue;
+            }
+            if (clearedPath === "/") {
+                clearedPath += formattedSegment;
+            }
+            else {
+                clearedPath += `/${formattedSegment}`;
+            }
+        }
+        const dotResult = [];
+        const result = [];
+        for (const element of clearedPath.split("/")) {
+            if (element === "..") {
+                const deletedElement = result.pop();
+                if (!deletedElement) {
+                    dotResult.push(element);
+                }
+            }
+            else {
+                result.push(element);
+            }
+        }
+        if (dotResult.length === 0) {
+            return result.join("/");
+        }
+        return `${dotResult.join("/")}/${result.join("/")}`;
+    }
+    Path.resolveRelative = resolveRelative;
+})(exports.Path || (exports.Path = {}));

package/dist/common/path.d.ts

@@ -0,0 +1,145 @@
+import * as DEither from "../either";
+import type { AnyTuple } from "./types";
+export declare namespace Path {
+    const baseNameRegex: RegExp;
+    const folderNameRegex: RegExp;
+    const extensionNameRegex: RegExp;
+    const isRelativeRegex: RegExp;
+    const segmentTrailingRegex: RegExp;
+    const segmentRelativeRegex: RegExp;
+    interface GetBaseNameParams {
+        removeExtension?: boolean;
+    }
+    /**
+     * Returns the last segment of a path (after the final slash), with optional extension removal.
+     * 
+     * **Supported call styles:**
+     * - Classic: `getBaseName(path, params?)` -> returns the base name or null
+     * 
+     * The path must contain at least one `/` to match. It returns null when no segment is found.
+     * When `removeExtension` is true, the file extension is removed from the base name.
+     * 
+     * ```ts
+     * const defaultResult = Path.getBaseName("/foo/bar.txt");
+     * // defaultResult: "bar.txt"
+     * const withoutExtResult = Path.getBaseName("/foo/bar.txt", { removeExtension: true });
+     * // withoutExtResult: "bar"
+     * const nullResult = Path.getBaseName("bar.txt");
+     * // nullResult: null
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/getBaseName
+     * 
+     */
+    function getBaseName<GenericPath extends string>(path: GenericPath, params?: GetBaseNameParams): string | null;
+    /**
+     * Returns the last extension of a path, without the leading dot.
+     * 
+     * **Supported call styles:**
+     * - Classic: `getExtensionName(path)` -> returns the extension or null
+     * 
+     * It returns null when no extension is found, when the path ends with a dot, or when the path is `..`.
+     * 
+     * ```ts
+     * const txtResult = Path.getExtensionName("/foo/bar.txt");
+     * // txtResult: "txt"
+     * const tarResult = Path.getExtensionName("archive.tar.gz");
+     * // tarResult: "gz"
+     * const dotResult = Path.getExtensionName("file.");
+     * // dotResult: null
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/getExtensionName
+     * 
+     */
+    function getExtensionName<GenericPath extends string>(path: GenericPath): string | null;
+    /**
+     * Returns the parent folder path of a POSIX path.
+     * 
+     * **Supported call styles:**
+     * - Classic: `getParentFolderPath(path)` -> returns the parent folder or null
+     * 
+     * The path must contain at least one `/` to match. It removes a trailing slash and drops the last segment.
+     * 
+     * ```ts
+     * const result = Path.getParentFolderPath("/foo/bar/baz");
+     * // result: "/foo/bar"
+     * const trailingResult = Path.getParentFolderPath("/foo/bar/");
+     * // trailingResult: "/foo"
+     * const relativeResult = Path.getParentFolderPath("foo");
+     * // relativeResult: null
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/getParentFolderPath
+     * 
+     */
+    function getParentFolderPath<GenericPath extends string>(path: GenericPath): string | null;
+    /**
+     * Checks whether a path is absolute (POSIX).
+     * 
+     * **Supported call styles:**
+     * - Classic: `isAbsolute(path)` -> returns a boolean
+     * 
+     * It returns true when the path starts with `/` and does not contain `..` segments.
+     * 
+     * ```ts
+     * const absolutePath = Path.isAbsolute("/var/log");
+     * // absolutePath: true
+     * const parentTraversal = Path.isAbsolute("/var/../log");
+     * // parentTraversal: false
+     * const relativePath = Path.isAbsolute("var/log");
+     * // relativePath: false
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/isAbsolute
+     * 
+     */
+    function isAbsolute<GenericPath extends string>(path: GenericPath): boolean;
+    /**
+     * Resolves a list of path segments from an origin and returns an Either.
+     * 
+     * **Supported call styles:**
+     * - Classic: `resolveFrom(origin, segments)` -> returns an Either
+     * 
+     * Segments are resolved in order using `resolveRelative`.
+     * The result is an `Either` that is `success` only when the resolved path is absolute; otherwise it returns `fail`.
+     * 
+     * ```ts
+     * const absoluteResult = Path.resolveFrom("/root", ["alpha", "beta"]);
+     * // absoluteResult: DEither.success<"/root/alpha/beta">
+     * const result = unwrap(absoluteResult);
+     * // result: "/root/alpha/beta"
+     * 
+     * const overrideResult = Path.resolveFrom("gamma", ["alpha", "/root", "beta"]);
+     * // overrideResult: DEither.success<"/root/beta">
+     * const relativeResult = Path.resolveFrom("alpha", ["..", ".."]);
+     * // relativeResult: DEither.fail
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveFrom
+     * 
+     */
+    function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.Fail | DEither.Success<string>;
+    /**
+     * Resolves path segments into a single POSIX-like path.
+     * 
+     * **Supported call styles:**
+     * - Classic: `resolveRelative(segments)` -> returns the resolved path
+     * 
+     * Empty segments are ignored, trailing slashes and leading `./` are removed, and absolute segments reset the base.
+     * `..` segments remove previous segments and may remain leading when resolving above root.
+     * 
+     * ```ts
+     * const basicResult = Path.resolveRelative(["alpha", "beta"]);
+     * // basicResult: "/alpha/beta"
+     * const overrideResult = Path.resolveRelative(["alpha", "/root", "beta"]);
+     * // overrideResult: "/root/beta"
+     * const parentResult = Path.resolveRelative(["alpha", "..", "..", "beta"]);
+     * // parentResult: "../beta"
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveRelative
+     * 
+     */
+    function resolveRelative<GenericSegment extends string>(segments: AnyTuple<GenericSegment>): string;
+}

package/dist/common/path.mjs

@@ -0,0 +1,114 @@
+import { success } from '../either/right/success.mjs';
+import { fail } from '../either/left/fail.mjs';
+
+var Path;
+(function (Path) {
+    Path.baseNameRegex = /\/?([^/]+)$/;
+    Path.folderNameRegex = /([^]+)\/[^/]+\/?$/;
+    Path.extensionNameRegex = /\.([^./]+)$/;
+    Path.isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+    Path.segmentTrailingRegex = /\/$/;
+    Path.segmentRelativeRegex = /^(.\/)/;
+    /**
+     * {@include common/path/getBaseName/index.md}
+     */
+    function getBaseName(path, params) {
+        const match = Path.baseNameRegex.exec(path);
+        if (!match) {
+            return null;
+        }
+        if (params?.removeExtension) {
+            return match[1].replace(Path.extensionNameRegex, "");
+        }
+        return match[1];
+    }
+    Path.getBaseName = getBaseName;
+    /**
+     * {@include common/path/getExtensionName/index.md}
+     */
+    function getExtensionName(path) {
+        const match = Path.extensionNameRegex.exec(path);
+        if (match) {
+            return match[1];
+        }
+        return null;
+    }
+    Path.getExtensionName = getExtensionName;
+    /**
+     * {@include common/path/getParentFolderPath/index.md}
+     */
+    function getParentFolderPath(path) {
+        const match = path.match(Path.folderNameRegex);
+        if (!match) {
+            return null;
+        }
+        return match[1];
+    }
+    Path.getParentFolderPath = getParentFolderPath;
+    /**
+     * {@include common/path/isAbsolute/index.md}
+     */
+    function isAbsolute(path) {
+        return path.startsWith("/")
+            && !Path.isRelativeRegex.test(path);
+    }
+    Path.isAbsolute = isAbsolute;
+    /**
+     * {@include common/path/resolveFrom/index.md}
+     */
+    function resolveFrom(origin, segments) {
+        const result = resolveRelative([origin, ...segments]);
+        return isAbsolute(result)
+            ? success(result)
+            : fail();
+    }
+    Path.resolveFrom = resolveFrom;
+    /**
+     * {@include common/path/resolveRelative/index.md}
+     */
+    function resolveRelative(segments) {
+        let clearedPath = "";
+        for (const segment of segments) {
+            if (segment.length === 0) {
+                continue;
+            }
+            if (segment === "/") {
+                clearedPath = segment;
+                continue;
+            }
+            const formattedSegment = segment
+                .replace(Path.segmentTrailingRegex, "")
+                .replace(Path.segmentRelativeRegex, "");
+            if (formattedSegment.startsWith("/")) {
+                clearedPath = formattedSegment;
+                continue;
+            }
+            if (clearedPath === "/") {
+                clearedPath += formattedSegment;
+            }
+            else {
+                clearedPath += `/${formattedSegment}`;
+            }
+        }
+        const dotResult = [];
+        const result = [];
+        for (const element of clearedPath.split("/")) {
+            if (element === "..") {
+                const deletedElement = result.pop();
+                if (!deletedElement) {
+                    dotResult.push(element);
+                }
+            }
+            else {
+                result.push(element);
+            }
+        }
+        if (dotResult.length === 0) {
+            return result.join("/");
+        }
+        return `${dotResult.join("/")}/${result.join("/")}`;
+    }
+    Path.resolveRelative = resolveRelative;
+})(Path || (Path = {}));
+
+export { Path };

package/dist/index.cjs

@@ -12,7 +12,6 @@ var index$8 = require('./dataParser/parsers/coerce/index.cjs');
 var index$9 = require('./dataParser/extended/index.cjs');
 var index$a = require('./date/index.cjs');
 var index$b = require('./clean/index.cjs');
-var index$c = require('./common/path/index.cjs');
 var addWrappedProperties = require('./common/addWrappedProperties.cjs');
 var asyncPipe = require('./common/asyncPipe.cjs');
 var clone = require('./common/clone.cjs');
@@ -26,6 +25,7 @@ var promiseObject = require('./common/promiseObject.cjs');
 var simpleClone = require('./common/simpleClone.cjs');
 var sleep = require('./common/sleep.cjs');
 var stringToBytes = require('./common/stringToBytes.cjs');
+var mimeType = require('./common/mimeType.cjs');
 var stringToMillisecond = require('./common/stringToMillisecond.cjs');
 var toJSON = require('./common/toJSON.cjs');
 var toTransform = require('./common/toTransform.cjs');
@@ -62,6 +62,7 @@ var hasKinds = require('./common/hasKinds.cjs');
 var toCurriedPredicate = require('./common/toCurriedPredicate.cjs');
 var pipeCall = require('./common/pipeCall.cjs');
 var asserts = require('./common/asserts.cjs');
+var path = require('./common/path.cjs');
 
 
 
@@ -89,7 +90,6 @@ exports.D = index$a;
 exports.DDate = index$a;
 exports.C = index$b;
 exports.DClean = index$b;
-exports.Path = index$c;
 exports.addWrappedProperties = addWrappedProperties.addWrappedProperties;
 exports.asyncPipe = asyncPipe.asyncPipe;
 exports.clone = clone.clone;
@@ -108,6 +108,7 @@ exports.simpleClone = simpleClone.simpleClone;
 exports.sleep = sleep.sleep;
 exports.InvalidBytesInStringError = stringToBytes.InvalidBytesInStringError;
 exports.stringToBytes = stringToBytes.stringToBytes;
+exports.mimeType = mimeType.mimeType;
 exports.InvalidMillisecondInStringError = stringToMillisecond.InvalidMillisecondInStringError;
 exports.stringToMillisecond = stringToMillisecond.stringToMillisecond;
 exports.toJSON = toJSON.toJSON;
@@ -152,3 +153,7 @@ exports.toCurriedPredicate = toCurriedPredicate.toCurriedPredicate;
 exports.pipeCall = pipeCall.pipeCall;
 exports.AssertsError = asserts.AssertsError;
 exports.asserts = asserts.asserts;
+Object.defineProperty(exports, "Path", {
+	enumerable: true,
+	get: function () { return path.Path; }
+});

package/dist/index.mjs

@@ -34,8 +34,6 @@ export { index$a as DDate };
 import * as index$b from './clean/index.mjs';
 export { index$b as C };
 export { index$b as DClean };
-import * as index$c from './common/path/index.mjs';
-export { index$c as Path };
 export { addWrappedProperties } from './common/addWrappedProperties.mjs';
 export { asyncPipe } from './common/asyncPipe.mjs';
 export { clone } from './common/clone.mjs';
@@ -49,6 +47,7 @@ export { promiseObject } from './common/promiseObject.mjs';
 export { simpleClone } from './common/simpleClone.mjs';
 export { sleep } from './common/sleep.mjs';
 export { InvalidBytesInStringError, stringToBytes } from './common/stringToBytes.mjs';
+export { mimeType } from './common/mimeType.mjs';
 export { InvalidMillisecondInStringError, stringToMillisecond } from './common/stringToMillisecond.mjs';
 export { toJSON } from './common/toJSON.mjs';
 export { toTransform } from './common/toTransform.mjs';
@@ -85,3 +84,4 @@ export { hasKinds } from './common/hasKinds.mjs';
 export { toCurriedPredicate } from './common/toCurriedPredicate.mjs';
 export { pipeCall } from './common/pipeCall.mjs';
 export { AssertsError, asserts } from './common/asserts.mjs';
+export { Path } from './common/path.mjs';

package/dist/metadata.json

@@ -999,74 +999,6 @@
     {
       "name": "common",
       "files": [
-        {
-          "name": "path",
-          "files": [
-            {
-              "name": "getBaseName.cjs"
-            },
-            {
-              "name": "getBaseName.d.ts"
-            },
-            {
-              "name": "getBaseName.mjs"
-            },
-            {
-              "name": "getExtensionName.cjs"
-            },
-            {
-              "name": "getExtensionName.d.ts"
-            },
-            {
-              "name": "getExtensionName.mjs"
-            },
-            {
-              "name": "getParentFolderPath.cjs"
-            },
-            {
-              "name": "getParentFolderPath.d.ts"
-            },
-            {
-              "name": "getParentFolderPath.mjs"
-            },
-            {
-              "name": "index.cjs"
-            },
-            {
-              "name": "index.d.ts"
-            },
-            {
-              "name": "index.mjs"
-            },
-            {
-              "name": "isAbsolute.cjs"
-            },
-            {
-              "name": "isAbsolute.d.ts"
-            },
-            {
-              "name": "isAbsolute.mjs"
-            },
-            {
-              "name": "resolveFrom.cjs"
-            },
-            {
-              "name": "resolveFrom.d.ts"
-            },
-            {
-              "name": "resolveFrom.mjs"
-            },
-            {
-              "name": "resolveRelative.cjs"
-            },
-            {
-              "name": "resolveRelative.d.ts"
-            },
-            {
-              "name": "resolveRelative.mjs"
-            }
-          ]
-        },
         {
           "name": "types",
           "files": [
@@ -1483,6 +1415,15 @@
         {
           "name": "memo.mjs"
         },
+        {
+          "name": "mimeType.cjs"
+        },
+        {
+          "name": "mimeType.d.ts"
+        },
+        {
+          "name": "mimeType.mjs"
+        },
         {
           "name": "or.cjs"
         },
@@ -1501,6 +1442,15 @@
         {
           "name": "override.mjs"
         },
+        {
+          "name": "path.cjs"
+        },
+        {
+          "name": "path.d.ts"
+        },
+        {
+          "name": "path.mjs"
+        },
         {
           "name": "pipe.cjs"
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.47",
+  "version": "1.4.49",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"

package/dist/common/path/getBaseName.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-var split = require('../../string/split.cjs');
-var findLast = require('../../array/findLast.cjs');
-var length = require('../../string/length.cjs');
-var endsWith = require('../../string/endsWith.cjs');
-var slice = require('../../string/slice.cjs');
-
-/**
- * {@include common/path/getBaseName/index.md}
- */
-function getBaseName(path, params) {
-    const segments = split.split(path, "/");
-    const lastSegment = findLast.findLast(segments, (value) => length.length(value) > 0) ?? null;
-    if (!lastSegment || lastSegment === "..") {
-        return null;
-    }
-    if (params?.extension && endsWith.endsWith(lastSegment, params?.extension)) {
-        const extensionLength = length.length(params.extension);
-        return slice.slice(lastSegment, 0, -extensionLength);
-    }
-    return lastSegment;
-}
-
-exports.getBaseName = getBaseName;

package/dist/common/path/getBaseName.d.ts

@@ -1,26 +0,0 @@
-interface GetBaseNameParams {
-    extension?: string;
-}
-/**
- * Returns the last non-empty segment of a path, optionally without an extension.
- * 
- * **Supported call styles:**
- * - Classic: `getBaseName(path, params?)` -> returns the base name or null
- * 
- * It ignores trailing slashes and returns null when the path has no segment or when the last segment is `..`.
- * When an extension is provided, it is removed only if it matches the end of the base name.
- * 
- * ```ts
- * const defaultResult = Path.getBaseName("/foo/bar.txt");
- * // defaultResult: "bar.txt"
- * const withoutExtResult = Path.getBaseName("/foo/bar.txt", { extension: ".txt" });
- * // withoutExtResult: "bar"
- * const nullResult = Path.getBaseName("..");
- * // nullResult: null
- * ```
- * 
- * @see https://utils.duplojs.dev/en/v1/api/common/path/getBaseName
- * 
- */
-export declare function getBaseName<GenericPath extends string>(path: GenericPath, params?: GetBaseNameParams): string | null;
-export {};

package/dist/common/path/getBaseName.mjs

@@ -1,23 +0,0 @@
-import { split } from '../../string/split.mjs';
-import { findLast } from '../../array/findLast.mjs';
-import { length } from '../../string/length.mjs';
-import { endsWith } from '../../string/endsWith.mjs';
-import { slice } from '../../string/slice.mjs';
-
-/**
- * {@include common/path/getBaseName/index.md}
- */
-function getBaseName(path, params) {
-    const segments = split(path, "/");
-    const lastSegment = findLast(segments, (value) => length(value) > 0) ?? null;
-    if (!lastSegment || lastSegment === "..") {
-        return null;
-    }
-    if (params?.extension && endsWith(lastSegment, params?.extension)) {
-        const extensionLength = length(params.extension);
-        return slice(lastSegment, 0, -extensionLength);
-    }
-    return lastSegment;
-}
-
-export { getBaseName };

package/dist/common/path/getExtensionName.cjs

@@ -1,17 +0,0 @@
-'use strict';
-
-var minElements = require('../../array/minElements.cjs');
-
-const extensionNameRegex = /\.([^./]+)$/;
-/**
- * {@include common/path/getExtensionName/index.md}
- */
-function getExtensionName(path) {
-    const match = extensionNameRegex.exec(path);
-    if (!!match && minElements.minElements(match, 2)) {
-        return match[1];
-    }
-    return null;
-}
-
-exports.getExtensionName = getExtensionName;

package/dist/common/path/getExtensionName.d.ts

@@ -1,21 +0,0 @@
-/**
- * Returns the last extension of a path, without the leading dot.
- * 
- * **Supported call styles:**
- * - Classic: `getExtensionName(path)` -> returns the extension or null
- * 
- * It returns null when no extension is found, when the path ends with a dot, or when the path is `..`.
- * 
- * ```ts
- * const txtResult = Path.getExtensionName("/foo/bar.txt");
- * // txtResult: "txt"
- * const tarResult = Path.getExtensionName("archive.tar.gz");
- * // tarResult: "gz"
- * const dotResult = Path.getExtensionName("file.");
- * // dotResult: null
- * ```
- * 
- * @see https://utils.duplojs.dev/en/v1/api/common/path/getExtensionName
- * 
- */
-export declare function getExtensionName<GenericPath extends string>(path: GenericPath): string | null;