@guanghechen/path 1.0.0-alpha.10

package/CHANGELOG.md

@@ -0,0 +1,102 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [1.0.0-alpha.10](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.9...@guanghechen/path@1.0.0-alpha.10) (2023-11-18)
+
+
+### Performance Improvements
+
+* 🔧 upgrade engine version requirement from '>= 16.0.0' to '>= 18.0.0' ([ddb9521](https://github.com/guanghechen/sora/commit/ddb9521b529b2ca838554794339b9e27ac80b8aa))
+
+
+
+
+
+# [1.0.0-alpha.9](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.8...@guanghechen/path@1.0.0-alpha.9) (2023-11-07)
+
+
+### Performance Improvements
+
+* 🔧 make tsconfig.json tidy ([809f8cf](https://github.com/guanghechen/sora/commit/809f8cf6b18da2d8fbba1566a5f4a783b52683da))
+
+
+
+
+
+# [1.0.0-alpha.8](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.7...@guanghechen/path@1.0.0-alpha.8) (2023-10-25)
+
+
+### Performance Improvements
+
+* ⬆️ ugprade dependencies ([e8e7a92](https://github.com/guanghechen/sora/commit/e8e7a92f58fbeee3afbb04e1ef023a894249c0bc))
+
+
+
+
+
+# [1.0.0-alpha.7](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.6...@guanghechen/path@1.0.0-alpha.7) (2023-10-16)
+
+
+### Performance Improvements
+
+* 🎨 support 'preferSlash' option for 'relativexx' funcs ([e59d415](https://github.com/guanghechen/sora/commit/e59d415df8272f6a5b8afed1f57152e4b44c89b8))
+
+
+
+
+
+# [1.0.0-alpha.6](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.5...@guanghechen/path@1.0.0-alpha.6) (2023-10-16)
+
+
+### Performance Improvements
+
+* :art:  refactor @guanghechen/path ([8952da3](https://github.com/guanghechen/sora/commit/8952da3154a042a10e76b356da7461a1f8ad8582))
+
+
+
+
+
+# [1.0.0-alpha.5](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.4...@guanghechen/path@1.0.0-alpha.5) (2023-10-16)
+
+
+### Performance Improvements
+
+* :art:  refactor @guanghechen/path and @guanghechen/filepath ([5952ac3](https://github.com/guanghechen/sora/commit/5952ac39fee92e807e3cccc8e4b4dfa1aba1fa34))
+* 🔧 remove unnecessary devDependencies ([944f3ae](https://github.com/guanghechen/sora/commit/944f3aee64e68ce52ca30237c7d0240a82c9c58f))
+
+
+
+
+
+# [1.0.0-alpha.4](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.3...@guanghechen/path@1.0.0-alpha.4) (2023-10-10)
+
+**Note:** Version bump only for package @guanghechen/path
+
+
+
+
+
+# [1.0.0-alpha.3](https://github.com/guanghechen/sora/compare/@guanghechen/path@1.0.0-alpha.2...@guanghechen/path@1.0.0-alpha.3) (2023-10-09)
+
+
+### Performance Improvements
+
+* re-expose @guanghechen/path.types ([92f5299](https://github.com/guanghechen/sora/commit/92f5299a62093f5e4167dda1b57adda1a45a3c8d))
+
+
+
+
+
+# 1.0.0-alpha.2 (2023-10-09)
+
+
+### Features
+
+* ✨ add @guanghechen/path ([cf68a08](https://github.com/guanghechen/sora/commit/cf68a08d661896d642254c58a5377b0556452cde))
+
+
+### Performance Improvements
+
+* ✅ update tests ([ad6cd01](https://github.com/guanghechen/sora/commit/ad6cd01188a9b3739dbe390053de9de3ea32770a))

package/lib/cjs/index.cjs

@@ -0,0 +1,270 @@
+'use strict';
+
+var path = require('node:path');
+var node_fs = require('node:fs');
+var node_url = require('node:url');
+var path_types = require('@guanghechen/path.types');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+const clazz$1 = 'PathResolver';
+class PathResolver {
+    basename(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = this.normalize(filepath);
+        return path__default.default.basename(p);
+    }
+    ensureAbsolute(filepath, message) {
+        if (this.isAbsolute(filepath))
+            return;
+        throw new Error(message ?? `[${clazz$1}] not an absolute path: ${filepath}.`);
+    }
+    ensureSafeRelative(root, filepath, message) {
+        if (this.isSafeRelative(root, filepath))
+            return;
+        throw new Error(message ?? `[${clazz$1}] not under the root path: filepath ${filepath}, root: ${root}.`);
+    }
+    dirname(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = path__default.default.dirname(filepath);
+        return this.normalize(p);
+    }
+    isAbsolute(filepath) {
+        return path__default.default.isAbsolute(filepath);
+    }
+    isSafeRelative(root, filepath) {
+        if (!this.isAbsolute(root))
+            return false;
+        const relativePath = this._internalSafeRelative(root, filepath);
+        return !relativePath.startsWith('..');
+    }
+    join(filepath, ...pathPieces) {
+        this.ensureAbsolute(filepath, `[${clazz$1}.join] not an absolute path: ${filepath}.`);
+        for (const pathPiece of pathPieces) {
+            if (this.isAbsolute(pathPiece)) {
+                throw new Error(`[${clazz$1}.join] pathPiece shouldn't be absolute path. ${pathPiece}`);
+            }
+        }
+        const p = path__default.default.join(filepath, ...pathPieces);
+        return this.normalize(p);
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(filepath);
+        return this._internalNormalize(filepath);
+    }
+    relative(from, to, preferSlash = false) {
+        this.ensureAbsolute(from, `[${clazz$1}.relative] from is not an absolute path: ${from}`);
+        this.ensureAbsolute(to, `[${clazz$1}.relative] to is not an absolute path: ${to}`);
+        const relativePath = this._internalRelative(from, to);
+        return preferSlash ? relativePath.replaceAll('\\', '/') : relativePath;
+    }
+    safeRelative(root, filepath, preferSlash = false) {
+        this.ensureSafeRelative(root, filepath);
+        const relativePath = this._internalSafeRelative(root, filepath);
+        return preferSlash ? relativePath.replaceAll('\\', '/') : relativePath;
+    }
+    safeResolve(root, filepath) {
+        this.ensureSafeRelative(root, filepath);
+        return this._internalSafeResolve(root, filepath);
+    }
+    _internalNormalize(filepath) {
+        const p = path__default.default
+            .normalize(filepath)
+            .replace(/[/\\]+/g, path__default.default.sep)
+            .replace(/[/\\]+$/, '');
+        return p.length <= 0 ? '/' : p;
+    }
+    _internalRelative(from_, to_) {
+        const from = this.normalize(from_);
+        const to = this.normalize(to_);
+        const relativePath = path__default.default.relative(from, to);
+        return relativePath;
+    }
+    _internalSafeRelative(root_, filepath_) {
+        const root = this._internalNormalize(root_);
+        const filepath = this._internalSafeResolve(root, filepath_);
+        const relativePath = this._internalRelative(root, filepath);
+        return relativePath;
+    }
+    _internalSafeResolve(root, filepath_) {
+        const filepath = this.isAbsolute(filepath_) ? filepath_ : path__default.default.join(root, filepath_);
+        return this._internalNormalize(filepath);
+    }
+}
+
+const clazz = 'UrlPathResolver';
+class UrlPathResolver {
+    basename(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = this.normalize(filepath);
+        const i = p.lastIndexOf('/');
+        return p.slice(i + 1);
+    }
+    ensureAbsolute(filepath, message) {
+        if (this.isAbsolute(filepath))
+            return;
+        throw new Error(message ?? `[${clazz}] not an absolute path: ${filepath}.`);
+    }
+    ensureSafeRelative(root, filepath, message) {
+        if (this.isSafeRelative(root, filepath))
+            return;
+        throw new Error(message ?? `[${clazz}] not under the root path: filepath ${filepath}, root: ${root}.`);
+    }
+    dirname(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = this.normalize(filepath);
+        const i = p.lastIndexOf('/');
+        return i <= 0 ? '/' : p.slice(0, i);
+    }
+    isAbsolute(filepath) {
+        return filepath.startsWith('/') || filepath.startsWith('\\');
+    }
+    isSafeRelative(root, filepath) {
+        if (!this.isAbsolute(root))
+            return false;
+        const relativePath = this._internalSafeRelative(root, filepath);
+        return !relativePath.startsWith('..');
+    }
+    join(filepath, ...pathPieces) {
+        this.ensureAbsolute(filepath, `[${clazz}.join] not an absolute path: ${filepath}.`);
+        for (const pathPiece of pathPieces) {
+            if (this.isAbsolute(pathPiece)) {
+                throw new Error(`[${clazz}.join] pathPiece shouldn't be absolute path. ${pathPiece}`);
+            }
+        }
+        return this._internalJoin(filepath, pathPieces.join('/'));
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(filepath);
+        return this._internalNormalize(filepath);
+    }
+    relative(from, to) {
+        this.ensureAbsolute(from, `[${clazz}.relative] from is not an absolute path: ${from}`);
+        this.ensureAbsolute(to, `[${clazz}.relative] to is not an absolute path: ${to}`);
+        return this._internalRelative(from, to);
+    }
+    safeRelative(root, filepath) {
+        this.ensureSafeRelative(root, filepath);
+        return this._internalSafeRelative(root, filepath);
+    }
+    safeResolve(root, filepath) {
+        this.ensureSafeRelative(root, filepath);
+        return this._internalSafeResolve(root, filepath);
+    }
+    _internalJoin(root, relativePath) {
+        const filepath = root + '/' + relativePath;
+        return this._internalNormalize(filepath);
+    }
+    _internalNormalize(filepath) {
+        const pieces = [];
+        for (const piece of filepath.split(/[/\\]+/g)) {
+            if (!piece)
+                continue;
+            if (piece === '.')
+                continue;
+            if (piece === '..') {
+                pieces.pop();
+                continue;
+            }
+            pieces.push(piece);
+        }
+        return '/' + pieces.join('/');
+    }
+    _internalRelative(from_, to_) {
+        const from = this.normalize(from_);
+        const to = this.normalize(to_);
+        const fromPieces = from.split('/');
+        const toPieces = to.split('/');
+        let ci = 0;
+        const L = fromPieces.length < toPieces.length ? fromPieces.length : toPieces.length;
+        for (; ci < L; ++ci) {
+            if (fromPieces[ci] !== toPieces[ci])
+                break;
+        }
+        return '../'.repeat(fromPieces.length - ci) + toPieces.slice(ci).join('/');
+    }
+    _internalSafeRelative(root_, filepath_) {
+        const root = this._internalNormalize(root_);
+        const filepath = this._internalSafeResolve(root, filepath_);
+        const relativePath = this._internalRelative(root, filepath);
+        return relativePath;
+    }
+    _internalSafeResolve(root, filepath_) {
+        const filepath = this.isAbsolute(filepath_) ? filepath_ : this.join(root, filepath_);
+        return filepath;
+    }
+}
+
+function locateNearestFilepath(currentDir, filenames) {
+    return internalRecursiveLocate(currentDir.startsWith('file://') ? node_url.fileURLToPath(currentDir) : currentDir, [filenames].flat());
+}
+function findNearestFilepath(currentDir, predicate) {
+    return internalFindNearestFilepath(currentDir.startsWith('file://') ? node_url.fileURLToPath(currentDir) : currentDir, predicate);
+}
+function internalRecursiveLocate(currentDir, filenames) {
+    for (const filename of filenames) {
+        const filepath = path.join(currentDir, filename);
+        if (node_fs.existsSync(filepath))
+            return filepath;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir || !path.isAbsolute(parentDir))
+        return null;
+    return locateNearestFilepath(parentDir, filenames);
+}
+function internalFindNearestFilepath(currentDir, predicate) {
+    const filenames = node_fs.readdirSync(currentDir);
+    for (const filename of filenames) {
+        const filepath = path.join(currentDir, filename);
+        if (predicate(filepath))
+            return filepath;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir)
+        return null;
+    return internalFindNearestFilepath(parentDir, predicate);
+}
+
+class WorkspacePathResolver {
+    root;
+    pathResolver;
+    constructor(root, pathResolver) {
+        this.root = root;
+        this.pathResolver = pathResolver;
+    }
+    ensureSafePath(filepath, message) {
+        const { root, pathResolver } = this;
+        pathResolver.ensureSafeRelative(root, filepath, message);
+    }
+    isSafePath(filepath) {
+        const { root, pathResolver } = this;
+        return pathResolver.isSafeRelative(root, filepath);
+    }
+    relative(filepath, preferSlash) {
+        const { root, pathResolver } = this;
+        return pathResolver.safeRelative(root, filepath, preferSlash);
+    }
+    resolve(filepath) {
+        const { root, pathResolver } = this;
+        return pathResolver.safeResolve(root, filepath);
+    }
+}
+
+const pathResolver = new PathResolver();
+const urlPathResolver = new UrlPathResolver();
+
+exports.PathResolver = PathResolver;
+exports.UrlPathResolver = UrlPathResolver;
+exports.WorkspacePathResolver = WorkspacePathResolver;
+exports.findNearestFilepath = findNearestFilepath;
+exports.locateNearestFilepath = locateNearestFilepath;
+exports.pathResolver = pathResolver;
+exports.urlPathResolver = urlPathResolver;
+Object.keys(path_types).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return path_types[k]; }
+    });
+});

package/lib/esm/index.mjs

@@ -0,0 +1,252 @@
+import path, { join, dirname, isAbsolute } from 'node:path';
+import { existsSync, readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export * from '@guanghechen/path.types';
+
+const clazz$1 = 'PathResolver';
+class PathResolver {
+    basename(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = this.normalize(filepath);
+        return path.basename(p);
+    }
+    ensureAbsolute(filepath, message) {
+        if (this.isAbsolute(filepath))
+            return;
+        throw new Error(message ?? `[${clazz$1}] not an absolute path: ${filepath}.`);
+    }
+    ensureSafeRelative(root, filepath, message) {
+        if (this.isSafeRelative(root, filepath))
+            return;
+        throw new Error(message ?? `[${clazz$1}] not under the root path: filepath ${filepath}, root: ${root}.`);
+    }
+    dirname(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = path.dirname(filepath);
+        return this.normalize(p);
+    }
+    isAbsolute(filepath) {
+        return path.isAbsolute(filepath);
+    }
+    isSafeRelative(root, filepath) {
+        if (!this.isAbsolute(root))
+            return false;
+        const relativePath = this._internalSafeRelative(root, filepath);
+        return !relativePath.startsWith('..');
+    }
+    join(filepath, ...pathPieces) {
+        this.ensureAbsolute(filepath, `[${clazz$1}.join] not an absolute path: ${filepath}.`);
+        for (const pathPiece of pathPieces) {
+            if (this.isAbsolute(pathPiece)) {
+                throw new Error(`[${clazz$1}.join] pathPiece shouldn't be absolute path. ${pathPiece}`);
+            }
+        }
+        const p = path.join(filepath, ...pathPieces);
+        return this.normalize(p);
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(filepath);
+        return this._internalNormalize(filepath);
+    }
+    relative(from, to, preferSlash = false) {
+        this.ensureAbsolute(from, `[${clazz$1}.relative] from is not an absolute path: ${from}`);
+        this.ensureAbsolute(to, `[${clazz$1}.relative] to is not an absolute path: ${to}`);
+        const relativePath = this._internalRelative(from, to);
+        return preferSlash ? relativePath.replaceAll('\\', '/') : relativePath;
+    }
+    safeRelative(root, filepath, preferSlash = false) {
+        this.ensureSafeRelative(root, filepath);
+        const relativePath = this._internalSafeRelative(root, filepath);
+        return preferSlash ? relativePath.replaceAll('\\', '/') : relativePath;
+    }
+    safeResolve(root, filepath) {
+        this.ensureSafeRelative(root, filepath);
+        return this._internalSafeResolve(root, filepath);
+    }
+    _internalNormalize(filepath) {
+        const p = path
+            .normalize(filepath)
+            .replace(/[/\\]+/g, path.sep)
+            .replace(/[/\\]+$/, '');
+        return p.length <= 0 ? '/' : p;
+    }
+    _internalRelative(from_, to_) {
+        const from = this.normalize(from_);
+        const to = this.normalize(to_);
+        const relativePath = path.relative(from, to);
+        return relativePath;
+    }
+    _internalSafeRelative(root_, filepath_) {
+        const root = this._internalNormalize(root_);
+        const filepath = this._internalSafeResolve(root, filepath_);
+        const relativePath = this._internalRelative(root, filepath);
+        return relativePath;
+    }
+    _internalSafeResolve(root, filepath_) {
+        const filepath = this.isAbsolute(filepath_) ? filepath_ : path.join(root, filepath_);
+        return this._internalNormalize(filepath);
+    }
+}
+
+const clazz = 'UrlPathResolver';
+class UrlPathResolver {
+    basename(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = this.normalize(filepath);
+        const i = p.lastIndexOf('/');
+        return p.slice(i + 1);
+    }
+    ensureAbsolute(filepath, message) {
+        if (this.isAbsolute(filepath))
+            return;
+        throw new Error(message ?? `[${clazz}] not an absolute path: ${filepath}.`);
+    }
+    ensureSafeRelative(root, filepath, message) {
+        if (this.isSafeRelative(root, filepath))
+            return;
+        throw new Error(message ?? `[${clazz}] not under the root path: filepath ${filepath}, root: ${root}.`);
+    }
+    dirname(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = this.normalize(filepath);
+        const i = p.lastIndexOf('/');
+        return i <= 0 ? '/' : p.slice(0, i);
+    }
+    isAbsolute(filepath) {
+        return filepath.startsWith('/') || filepath.startsWith('\\');
+    }
+    isSafeRelative(root, filepath) {
+        if (!this.isAbsolute(root))
+            return false;
+        const relativePath = this._internalSafeRelative(root, filepath);
+        return !relativePath.startsWith('..');
+    }
+    join(filepath, ...pathPieces) {
+        this.ensureAbsolute(filepath, `[${clazz}.join] not an absolute path: ${filepath}.`);
+        for (const pathPiece of pathPieces) {
+            if (this.isAbsolute(pathPiece)) {
+                throw new Error(`[${clazz}.join] pathPiece shouldn't be absolute path. ${pathPiece}`);
+            }
+        }
+        return this._internalJoin(filepath, pathPieces.join('/'));
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(filepath);
+        return this._internalNormalize(filepath);
+    }
+    relative(from, to) {
+        this.ensureAbsolute(from, `[${clazz}.relative] from is not an absolute path: ${from}`);
+        this.ensureAbsolute(to, `[${clazz}.relative] to is not an absolute path: ${to}`);
+        return this._internalRelative(from, to);
+    }
+    safeRelative(root, filepath) {
+        this.ensureSafeRelative(root, filepath);
+        return this._internalSafeRelative(root, filepath);
+    }
+    safeResolve(root, filepath) {
+        this.ensureSafeRelative(root, filepath);
+        return this._internalSafeResolve(root, filepath);
+    }
+    _internalJoin(root, relativePath) {
+        const filepath = root + '/' + relativePath;
+        return this._internalNormalize(filepath);
+    }
+    _internalNormalize(filepath) {
+        const pieces = [];
+        for (const piece of filepath.split(/[/\\]+/g)) {
+            if (!piece)
+                continue;
+            if (piece === '.')
+                continue;
+            if (piece === '..') {
+                pieces.pop();
+                continue;
+            }
+            pieces.push(piece);
+        }
+        return '/' + pieces.join('/');
+    }
+    _internalRelative(from_, to_) {
+        const from = this.normalize(from_);
+        const to = this.normalize(to_);
+        const fromPieces = from.split('/');
+        const toPieces = to.split('/');
+        let ci = 0;
+        const L = fromPieces.length < toPieces.length ? fromPieces.length : toPieces.length;
+        for (; ci < L; ++ci) {
+            if (fromPieces[ci] !== toPieces[ci])
+                break;
+        }
+        return '../'.repeat(fromPieces.length - ci) + toPieces.slice(ci).join('/');
+    }
+    _internalSafeRelative(root_, filepath_) {
+        const root = this._internalNormalize(root_);
+        const filepath = this._internalSafeResolve(root, filepath_);
+        const relativePath = this._internalRelative(root, filepath);
+        return relativePath;
+    }
+    _internalSafeResolve(root, filepath_) {
+        const filepath = this.isAbsolute(filepath_) ? filepath_ : this.join(root, filepath_);
+        return filepath;
+    }
+}
+
+function locateNearestFilepath(currentDir, filenames) {
+    return internalRecursiveLocate(currentDir.startsWith('file://') ? fileURLToPath(currentDir) : currentDir, [filenames].flat());
+}
+function findNearestFilepath(currentDir, predicate) {
+    return internalFindNearestFilepath(currentDir.startsWith('file://') ? fileURLToPath(currentDir) : currentDir, predicate);
+}
+function internalRecursiveLocate(currentDir, filenames) {
+    for (const filename of filenames) {
+        const filepath = join(currentDir, filename);
+        if (existsSync(filepath))
+            return filepath;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir || !isAbsolute(parentDir))
+        return null;
+    return locateNearestFilepath(parentDir, filenames);
+}
+function internalFindNearestFilepath(currentDir, predicate) {
+    const filenames = readdirSync(currentDir);
+    for (const filename of filenames) {
+        const filepath = join(currentDir, filename);
+        if (predicate(filepath))
+            return filepath;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir)
+        return null;
+    return internalFindNearestFilepath(parentDir, predicate);
+}
+
+class WorkspacePathResolver {
+    root;
+    pathResolver;
+    constructor(root, pathResolver) {
+        this.root = root;
+        this.pathResolver = pathResolver;
+    }
+    ensureSafePath(filepath, message) {
+        const { root, pathResolver } = this;
+        pathResolver.ensureSafeRelative(root, filepath, message);
+    }
+    isSafePath(filepath) {
+        const { root, pathResolver } = this;
+        return pathResolver.isSafeRelative(root, filepath);
+    }
+    relative(filepath, preferSlash) {
+        const { root, pathResolver } = this;
+        return pathResolver.safeRelative(root, filepath, preferSlash);
+    }
+    resolve(filepath) {
+        const { root, pathResolver } = this;
+        return pathResolver.safeResolve(root, filepath);
+    }
+}
+
+const pathResolver = new PathResolver();
+const urlPathResolver = new UrlPathResolver();
+
+export { PathResolver, UrlPathResolver, WorkspacePathResolver, findNearestFilepath, locateNearestFilepath, pathResolver, urlPathResolver };

package/lib/types/index.d.ts

@@ -0,0 +1,71 @@
+import { IPathResolver, IWorkspacePathResolver } from '@guanghechen/path.types';
+export * from '@guanghechen/path.types';
+
+/**
+ * Locate a nearest filepath from the given `currentDir` which name included in the give `filenames`.
+ *
+ * @param currentDir
+ * @param filenames
+ * @returns
+ */
+declare function locateNearestFilepath(currentDir: string, filenames: string | ReadonlyArray<string>): string | null;
+/**
+ * Find a nearest filepath from the give `currentDir`which matched the give tester `testFilepath`.
+ *
+ * @param currentDir
+ * @param predicate
+ * @returns
+ */
+declare function findNearestFilepath(currentDir: string, predicate: (filepath: string) => boolean): string | null;
+
+declare class PathResolver implements IPathResolver {
+    basename(filepath: string): string;
+    ensureAbsolute(filepath: string, message?: string | undefined): void | never;
+    ensureSafeRelative(root: string, filepath: string, message?: string | undefined): void | never;
+    dirname(filepath: string): string | never;
+    isAbsolute(filepath: string): boolean;
+    isSafeRelative(root: string, filepath: string): boolean;
+    join(filepath: string, ...pathPieces: string[]): string | never;
+    normalize(filepath: string): string | never;
+    relative(from: string, to: string, preferSlash?: boolean): string | never;
+    safeRelative(root: string, filepath: string, preferSlash?: boolean): string;
+    safeResolve(root: string, filepath: string): string;
+    protected _internalNormalize(filepath: string): string;
+    protected _internalRelative(from_: string, to_: string): string;
+    protected _internalSafeRelative(root_: string, filepath_: string): string;
+    protected _internalSafeResolve(root: string, filepath_: string): string;
+}
+
+declare class UrlPathResolver implements IPathResolver {
+    basename(filepath: string): string;
+    ensureAbsolute(filepath: string, message?: string | undefined): void | never;
+    ensureSafeRelative(root: string, filepath: string, message?: string | undefined): void;
+    dirname(filepath: string): string | never;
+    isAbsolute(filepath: string): boolean;
+    isSafeRelative(root: string, filepath: string): boolean;
+    join(filepath: string, ...pathPieces: string[]): string | never;
+    normalize(filepath: string): string | never;
+    relative(from: string, to: string): string | never;
+    safeRelative(root: string, filepath: string): string;
+    safeResolve(root: string, filepath: string): string;
+    protected _internalJoin(root: string, relativePath: string): string;
+    protected _internalNormalize(filepath: string): string;
+    protected _internalRelative(from_: string, to_: string): string;
+    protected _internalSafeRelative(root_: string, filepath_: string): string;
+    protected _internalSafeResolve(root: string, filepath_: string): string;
+}
+
+declare class WorkspacePathResolver implements IWorkspacePathResolver {
+    readonly root: string;
+    readonly pathResolver: IPathResolver;
+    constructor(root: string, pathResolver: IPathResolver);
+    ensureSafePath(filepath: string, message?: string | undefined): void | never;
+    isSafePath(filepath: string): boolean;
+    relative(filepath: string, preferSlash?: boolean): string | never;
+    resolve(filepath: string): string | never;
+}
+
+declare const pathResolver: IPathResolver;
+declare const urlPathResolver: IPathResolver;
+
+export { PathResolver, UrlPathResolver, WorkspacePathResolver, findNearestFilepath, locateNearestFilepath, pathResolver, urlPathResolver };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@guanghechen/path",
+  "version": "1.0.0-alpha.10",
+  "description": "Path utils.",
+  "author": {
+    "name": "guanghechen",
+    "url": "https://github.com/guanghechen/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guanghechen/sora/tree/@guanghechen/path@1.0.0-alpha.9",
+    "directory": "packages/path"
+  },
+  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/path@1.0.0-alpha.9/packages/path#readme",
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./lib/esm/index.mjs",
+      "require": "./lib/cjs/index.cjs",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "source": "./src/index.ts",
+  "main": "./lib/cjs/index.cjs",
+  "module": "./lib/esm/index.mjs",
+  "types": "./lib/types/index.d.ts",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map",
+    "package.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "../../node_modules/.bin/rimraf lib/ && ../../node_modules/.bin/cross-env NODE_ENV=production ../../node_modules/.bin/rollup -c ../../rollup.config.mjs",
+    "prepublishOnly": "yarn build",
+    "test": "node --experimental-vm-modules ../../node_modules/.bin/jest --config ../../jest.config.mjs --rootDir ."
+  },
+  "dependencies": {
+    "@guanghechen/path.types": "^1.0.0-alpha.7"
+  },
+  "gitHead": "5c53d6c6b20a5bc1e97a19f97c6adfe88067a7f9"
+}