@guanghechen/path 1.0.0-alpha.2

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# 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.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,176 @@
+'use strict';
+
+var path = require('node:path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+const clazz$2 = 'PhysicalPathResolver';
+class PhysicalPathResolver {
+    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$2}] not an absolute path: ${filepath}.`);
+    }
+    dirname(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = path__default.default.dirname(filepath);
+        return this.normalize(p);
+    }
+    isAbsolute(filepath) {
+        return path__default.default.isAbsolute(filepath);
+    }
+    join(filepath, ...pathPieces) {
+        this.ensureAbsolute(filepath, `[${clazz$2}.join] not an absolute path: ${filepath}.`);
+        for (const pathPiece of pathPieces) {
+            if (this.isAbsolute(pathPiece)) {
+                throw new Error(`[${clazz$2}.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);
+        const p = path__default.default
+            .normalize(filepath)
+            .replace(/[/\\]+/g, path__default.default.sep)
+            .replace(/[/\\]+$/, '');
+        return p.length <= 0 ? '/' : p;
+    }
+    relative(from_, to_) {
+        this.ensureAbsolute(from_, `[${clazz$2}.relative] from is not an absolute path: ${from_}`);
+        this.ensureAbsolute(to_, `[${clazz$2}.relative] to is not an absolute path: ${to_}`);
+        const from = this.normalize(from_);
+        const to = this.normalize(to_);
+        const relativePath = path__default.default.relative(from, to);
+        return relativePath;
+    }
+}
+
+const clazz$1 = 'WorkspacePathResolver';
+class WorkspacePathResolver {
+    root;
+    pathResolver;
+    constructor(root, pathResolver) {
+        this.root = root;
+        this.pathResolver = pathResolver;
+    }
+    ensureSafePath(filepath, message) {
+        if (this.isSafePath(filepath))
+            return;
+        throw new Error(message ?? `[${clazz$1}] not an absolute path: ${filepath}.`);
+    }
+    isSafePath(filepath) {
+        const { root, pathResolver } = this;
+        if (!pathResolver.isAbsolute(filepath))
+            return true;
+        if (filepath === root)
+            return true;
+        const relativePath = pathResolver.relative(root, filepath);
+        return !relativePath.startsWith('..');
+    }
+    resolve(filepath) {
+        this.ensureSafePath(filepath);
+        const { root, pathResolver } = this;
+        if (pathResolver.isAbsolute(filepath))
+            return pathResolver.normalize(filepath);
+        return pathResolver.join(root, filepath);
+    }
+    relative(filepath_) {
+        this.ensureSafePath(filepath_);
+        const filepath = this.resolve(filepath_);
+        return this.pathResolver.relative(this.root, filepath);
+    }
+}
+
+class PhysicalWorkspacePathResolver extends WorkspacePathResolver {
+    constructor(root) {
+        const pathResolver = new PhysicalPathResolver();
+        super(root, pathResolver);
+    }
+}
+
+const clazz = 'VirtualPathResolver';
+class VirtualPathResolver {
+    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}.`);
+    }
+    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('\\');
+    }
+    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}`);
+            }
+        }
+        const p = filepath + '/' + pathPieces.join('/');
+        return this.normalize(p);
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(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('/');
+    }
+    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_}`);
+        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('/');
+    }
+}
+
+class VirtualWorkspacePathResolver extends WorkspacePathResolver {
+    constructor(root) {
+        const pathResolver = new VirtualPathResolver();
+        super(root, pathResolver);
+    }
+}
+
+exports.PhysicalPathResolver = PhysicalPathResolver;
+exports.PhysicalWorkspacePathResolver = PhysicalWorkspacePathResolver;
+exports.VirtualPathResolver = VirtualPathResolver;
+exports.VirtualWorkspacePathResolver = VirtualWorkspacePathResolver;
+exports.WorkspacePathResolver = WorkspacePathResolver;

package/lib/esm/index.mjs

@@ -0,0 +1,166 @@
+import path from 'node:path';
+
+const clazz$2 = 'PhysicalPathResolver';
+class PhysicalPathResolver {
+    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$2}] not an absolute path: ${filepath}.`);
+    }
+    dirname(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = path.dirname(filepath);
+        return this.normalize(p);
+    }
+    isAbsolute(filepath) {
+        return path.isAbsolute(filepath);
+    }
+    join(filepath, ...pathPieces) {
+        this.ensureAbsolute(filepath, `[${clazz$2}.join] not an absolute path: ${filepath}.`);
+        for (const pathPiece of pathPieces) {
+            if (this.isAbsolute(pathPiece)) {
+                throw new Error(`[${clazz$2}.join] pathPiece shouldn't be absolute path. ${pathPiece}`);
+            }
+        }
+        const p = path.join(filepath, ...pathPieces);
+        return this.normalize(p);
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(filepath);
+        const p = path
+            .normalize(filepath)
+            .replace(/[/\\]+/g, path.sep)
+            .replace(/[/\\]+$/, '');
+        return p.length <= 0 ? '/' : p;
+    }
+    relative(from_, to_) {
+        this.ensureAbsolute(from_, `[${clazz$2}.relative] from is not an absolute path: ${from_}`);
+        this.ensureAbsolute(to_, `[${clazz$2}.relative] to is not an absolute path: ${to_}`);
+        const from = this.normalize(from_);
+        const to = this.normalize(to_);
+        const relativePath = path.relative(from, to);
+        return relativePath;
+    }
+}
+
+const clazz$1 = 'WorkspacePathResolver';
+class WorkspacePathResolver {
+    root;
+    pathResolver;
+    constructor(root, pathResolver) {
+        this.root = root;
+        this.pathResolver = pathResolver;
+    }
+    ensureSafePath(filepath, message) {
+        if (this.isSafePath(filepath))
+            return;
+        throw new Error(message ?? `[${clazz$1}] not an absolute path: ${filepath}.`);
+    }
+    isSafePath(filepath) {
+        const { root, pathResolver } = this;
+        if (!pathResolver.isAbsolute(filepath))
+            return true;
+        if (filepath === root)
+            return true;
+        const relativePath = pathResolver.relative(root, filepath);
+        return !relativePath.startsWith('..');
+    }
+    resolve(filepath) {
+        this.ensureSafePath(filepath);
+        const { root, pathResolver } = this;
+        if (pathResolver.isAbsolute(filepath))
+            return pathResolver.normalize(filepath);
+        return pathResolver.join(root, filepath);
+    }
+    relative(filepath_) {
+        this.ensureSafePath(filepath_);
+        const filepath = this.resolve(filepath_);
+        return this.pathResolver.relative(this.root, filepath);
+    }
+}
+
+class PhysicalWorkspacePathResolver extends WorkspacePathResolver {
+    constructor(root) {
+        const pathResolver = new PhysicalPathResolver();
+        super(root, pathResolver);
+    }
+}
+
+const clazz = 'VirtualPathResolver';
+class VirtualPathResolver {
+    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}.`);
+    }
+    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('\\');
+    }
+    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}`);
+            }
+        }
+        const p = filepath + '/' + pathPieces.join('/');
+        return this.normalize(p);
+    }
+    normalize(filepath) {
+        this.ensureAbsolute(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('/');
+    }
+    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_}`);
+        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('/');
+    }
+}
+
+class VirtualWorkspacePathResolver extends WorkspacePathResolver {
+    constructor(root) {
+        const pathResolver = new VirtualPathResolver();
+        super(root, pathResolver);
+    }
+}
+
+export { PhysicalPathResolver, PhysicalWorkspacePathResolver, VirtualPathResolver, VirtualWorkspacePathResolver, WorkspacePathResolver };

package/lib/types/index.d.ts

@@ -0,0 +1,41 @@
+import { IPathResolver, IWorkspacePathResolver } from '@guanghechen/path.types';
+
+declare class PhysicalPathResolver implements IPathResolver {
+    basename(filepath: string): string;
+    ensureAbsolute(filepath: string, message?: string | undefined): void | never;
+    dirname(filepath: string): string | never;
+    isAbsolute(filepath: string): boolean;
+    join(filepath: string, ...pathPieces: string[]): string | never;
+    normalize(filepath: string): string | never;
+    relative(from_: string, to_: string): string | never;
+}
+
+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;
+    resolve(filepath: string): string | never;
+    relative(filepath_: string): string | never;
+}
+
+declare class PhysicalWorkspacePathResolver extends WorkspacePathResolver implements IWorkspacePathResolver {
+    constructor(root: string);
+}
+
+declare class VirtualPathResolver implements IPathResolver {
+    basename(filepath: string): string;
+    ensureAbsolute(filepath: string, message?: string | undefined): void | never;
+    dirname(filepath: string): string | never;
+    isAbsolute(filepath: string): boolean;
+    join(filepath: string, ...pathPieces: string[]): string | never;
+    normalize(filepath: string): string | never;
+    relative(from_: string, to_: string): string | never;
+}
+
+declare class VirtualWorkspacePathResolver extends WorkspacePathResolver implements IWorkspacePathResolver {
+    constructor(root: string);
+}
+
+export { PhysicalPathResolver, PhysicalWorkspacePathResolver, VirtualPathResolver, VirtualWorkspacePathResolver, WorkspacePathResolver };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@guanghechen/path",
+  "version": "1.0.0-alpha.2",
+  "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.1",
+    "directory": "packages/path"
+  },
+  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/path@1.0.0-alpha.1/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": ">= 16.0.0"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map",
+    "package.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rimraf lib/ && cross-env NODE_ENV=production 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.2"
+  },
+  "devDependencies": {
+    "cross-env": "*",
+    "rimraf": "*",
+    "rollup": "*"
+  },
+  "gitHead": "b8d110d46e40575b2c7bc018ea823a779c3cff5a"
+}