@duplojs/utils 1.4.47 → 1.4.49

package/dist/common/path/getExtensionName.mjs

@@ -1,15 +0,0 @@
-import { minElements } from '../../array/minElements.mjs';
-
-const extensionNameRegex = /\.([^./]+)$/;
-/**
- * {@include common/path/getExtensionName/index.md}
- */
-function getExtensionName(path) {
-    const match = extensionNameRegex.exec(path);
-    if (!!match && minElements(match, 2)) {
-        return match[1];
-    }
-    return null;
-}
-
-export { getExtensionName };

package/dist/common/path/getParentFolderPath.cjs

@@ -1,21 +0,0 @@
-'use strict';
-
-var pipe = require('../pipe.cjs');
-var isAbsolute = require('./isAbsolute.cjs');
-var slice = require('../../array/slice.cjs');
-var split = require('../../string/split.cjs');
-var replace = require('../../string/replace.cjs');
-var join = require('../../array/join.cjs');
-
-/**
- * {@include common/path/getParentFolderPath/index.md}
- */
-function getParentFolderPath(path) {
-    const segments = pipe.pipe(path, replace.replace(/\/$/, ""), split.split("/"), slice.slice(0, -1));
-    return join.join(segments, "/")
-        || (isAbsolute.isAbsolute(path)
-            ? "/"
-            : ".");
-}
-
-exports.getParentFolderPath = getParentFolderPath;

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

@@ -1,23 +0,0 @@
-/**
- * Returns the parent folder path of a POSIX path.
- * 
- * **Supported call styles:**
- * - Classic: `getParentFolderPath(path)` -> returns the parent folder
- * 
- * It removes a trailing slash, drops the last segment, and falls back to `/` for absolute paths or `.` for relative paths when needed.
- * 
- * ```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: "."
- * const absoluteResult = Path.getParentFolderPath("/foo");
- * // absoluteResult: "/"
- * ```
- * 
- * @see https://utils.duplojs.dev/en/v1/api/common/path/getParentFolderPath
- * 
- */
-export declare function getParentFolderPath<GenericPath extends string>(path: GenericPath): string;

package/dist/common/path/getParentFolderPath.mjs

@@ -1,19 +0,0 @@
-import { pipe } from '../pipe.mjs';
-import { isAbsolute } from './isAbsolute.mjs';
-import { slice } from '../../array/slice.mjs';
-import { split } from '../../string/split.mjs';
-import { replace } from '../../string/replace.mjs';
-import { join } from '../../array/join.mjs';
-
-/**
- * {@include common/path/getParentFolderPath/index.md}
- */
-function getParentFolderPath(path) {
-    const segments = pipe(path, replace(/\/$/, ""), split("/"), slice(0, -1));
-    return join(segments, "/")
-        || (isAbsolute(path)
-            ? "/"
-            : ".");
-}
-
-export { getParentFolderPath };

package/dist/common/path/index.cjs

@@ -1,19 +0,0 @@
-'use strict';
-
-var isAbsolute = require('./isAbsolute.cjs');
-var getParentFolderPath = require('./getParentFolderPath.cjs');
-var getBaseName = require('./getBaseName.cjs');
-var getExtensionName = require('./getExtensionName.cjs');
-var resolveFrom = require('./resolveFrom.cjs');
-var resolveRelative = require('./resolveRelative.cjs');
-
-/**
- * {@include common/path/index.md}
- */
-
-exports.isAbsolute = isAbsolute.isAbsolute;
-exports.getParentFolderPath = getParentFolderPath.getParentFolderPath;
-exports.getBaseName = getBaseName.getBaseName;
-exports.getExtensionName = getExtensionName.getExtensionName;
-exports.resolveFrom = resolveFrom.resolveFrom;
-exports.resolveRelative = resolveRelative.resolveRelative;

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

@@ -1,27 +0,0 @@
-/**
- * Path utilities to resolve and inspect POSIX paths.
- * They preserve input strings and return new values.
- * 
- * **How to import:**
- * - From the main common namespace
- * - Via direct import for tree-shaking
- * 
- * ```ts
- * import { Path } from "@duplojs/utils";
- * import * as Path from "@duplojs/utils/common/path";
- * ```
- * 
- * What you will find in this namespace:
- * - checks (`Path.isAbsolute`)
- * - resolution (`Path.resolveFrom`, `Path.resolveRelative`)
- * - path parsing (`Path.getParentFolderPath`, `Path.getBaseName`, `Path.getExtensionName`)
- * 
- * @see https://utils.duplojs.dev/en/v1/api/common/path
- * 
- */
-export * from "./isAbsolute";
-export * from "./getParentFolderPath";
-export * from "./getBaseName";
-export * from "./getExtensionName";
-export * from "./resolveFrom";
-export * from "./resolveRelative";

package/dist/common/path/index.mjs

@@ -1,10 +0,0 @@
-export { isAbsolute } from './isAbsolute.mjs';
-export { getParentFolderPath } from './getParentFolderPath.mjs';
-export { getBaseName } from './getBaseName.mjs';
-export { getExtensionName } from './getExtensionName.mjs';
-export { resolveFrom } from './resolveFrom.mjs';
-export { resolveRelative } from './resolveRelative.mjs';
-
-/**
- * {@include common/path/index.md}
- */

package/dist/common/path/isAbsolute.cjs

@@ -1,15 +0,0 @@
-'use strict';
-
-var startsWith = require('../../string/startsWith.cjs');
-var test = require('../../string/test.cjs');
-
-const isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
-/**
- * {@include common/path/isAbsolute/index.md}
- */
-function isAbsolute(path) {
-    return startsWith.startsWith(path, "/")
-        && !test.test(path, isRelativeRegex);
-}
-
-exports.isAbsolute = isAbsolute;

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

@@ -1,21 +0,0 @@
-/**
- * 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
- * 
- */
-export declare function isAbsolute<GenericPath extends string>(path: GenericPath): boolean;

package/dist/common/path/isAbsolute.mjs

@@ -1,13 +0,0 @@
-import { startsWith } from '../../string/startsWith.mjs';
-import { test } from '../../string/test.mjs';
-
-const isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
-/**
- * {@include common/path/isAbsolute/index.md}
- */
-function isAbsolute(path) {
-    return startsWith(path, "/")
-        && !test(path, isRelativeRegex);
-}
-
-export { isAbsolute };

package/dist/common/path/resolveFrom.cjs

@@ -1,18 +0,0 @@
-'use strict';
-
-var isAbsolute = require('./isAbsolute.cjs');
-var resolveRelative = require('./resolveRelative.cjs');
-var success = require('../../either/right/success.cjs');
-var fail = require('../../either/left/fail.cjs');
-
-/**
- * {@include common/path/resolveFrom/index.md}
- */
-function resolveFrom(origin, segments) {
-    const result = resolveRelative.resolveRelative([origin, ...segments]);
-    return isAbsolute.isAbsolute(result)
-        ? success.success(result)
-        : fail.fail();
-}
-
-exports.resolveFrom = resolveFrom;

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

@@ -1,27 +0,0 @@
-import * as DEither from "../../either";
-import type { AnyTuple } from "../types";
-/**
- * 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
- * 
- */
-export declare function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.Fail | DEither.Success<string>;

package/dist/common/path/resolveFrom.mjs

@@ -1,16 +0,0 @@
-import { isAbsolute } from './isAbsolute.mjs';
-import { resolveRelative } from './resolveRelative.mjs';
-import { success } from '../../either/right/success.mjs';
-import { fail } from '../../either/left/fail.mjs';
-
-/**
- * {@include common/path/resolveFrom/index.md}
- */
-function resolveFrom(origin, segments) {
-    const result = resolveRelative([origin, ...segments]);
-    return isAbsolute(result)
-        ? success(result)
-        : fail();
-}
-
-export { resolveFrom };

package/dist/common/path/resolveRelative.cjs

@@ -1,51 +0,0 @@
-'use strict';
-
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(.\/)/;
-/**
- * {@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(segmentTrailingRegex, "")
-            .replace(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("/")}`;
-}
-
-exports.resolveRelative = resolveRelative;

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

@@ -1,23 +0,0 @@
-import type { AnyTuple } from "../types";
-/**
- * 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
- * 
- */
-export declare function resolveRelative<GenericSegment extends string>(segments: AnyTuple<GenericSegment>): string;

package/dist/common/path/resolveRelative.mjs

@@ -1,49 +0,0 @@
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(.\/)/;
-/**
- * {@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(segmentTrailingRegex, "")
-            .replace(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("/")}`;
-}
-
-export { resolveRelative };