@hamak/navigation-utils 0.4.0

package/src/path/pathway.ts

@@ -0,0 +1,232 @@
+export type Path = string | string[] | Pathway
+/**
+ * Class representing a normalized pathway.
+ */
+export class Pathway {
+  private segments: string[];
+  private isAbsolutePath: boolean;
+
+  /**
+   * Creates a Pathway instance.
+   * @param path - The pathway to normalize, either as a string or an array of strings.
+   *                An empty array or "." represents the current directory.
+   */
+  constructor(path: string | string[] | null | undefined) {
+    if (path == null || path === "." || (Array.isArray(path) && path.length === 0)) {
+      this.segments = [];
+      this.isAbsolutePath = false;
+    } else {
+      this.isAbsolutePath = Array.isArray(path) ? path[0].startsWith('/') : path.startsWith('/');
+      this.segments = this.normalizePath(path);
+    }
+  }
+
+  /**
+   * Factory method to create a Pathway instance.
+   * @param path - The pathway to normalize, either as a string or an array of strings.
+   * @returns A new Pathway instance.
+   */
+  public static of(path: string | string[] | null | undefined | Pathway): Pathway {
+    if(path !== undefined && path !== null && typeof path === "object" && !Array.isArray(path)) {
+      return path
+    } else {
+      return new Pathway(path);
+    }
+  }
+
+  /**
+   * Normalizes a pathway by converting it into an array of segments.
+   * @param path - The pathway to normalize, either as a string or an array of strings.
+   * @returns An array of normalized path segments, or an empty array if the input is null or undefined.
+   */
+  private normalizePath(path: string | string[] | null | undefined): string[] {
+    if (path == null) {
+      return [];
+    }
+
+    const segments = Array.isArray(path) ? path : path.split('/');
+    return segments
+      .reduce((acc, segment) => {
+        if (segment === "." || segment === "") {
+          return acc;
+        }
+        return acc.concat(segment.split('/'));
+      }, [] as string[])
+      .filter(segment => segment.length > 0);
+  }
+
+  /**
+   * Returns the normalized path segments.
+   * @returns An array of normalized path segments.
+   */
+  public getSegments(): string[] {
+    return this.segments;
+  }
+
+  public isCurrentDir(){
+    return this.getSegments().length === 0
+  }
+
+  /**
+   * Converts the normalized path segments back to a string.
+   * @returns The normalized path as a string.
+   */
+  public toString(): string {
+    return this.isAbsolute() ? '/' + this.segments.join('/') : this.segments.join('/');
+  }
+
+  /**
+   * Checks if the pathway is absolute.
+   * @returns True if the pathway is absolute, false otherwise.
+   */
+  public isAbsolute(): boolean {
+    return this.isAbsolutePath;
+  }
+
+  /**
+   * Checks if the pathway is relative.
+   * @returns True if the pathway is relative, false otherwise.
+   */
+  public isRelative(): boolean {
+    return !this.isAbsolutePath;
+  }
+
+  /**
+   * Resolves the current pathway with another pathway or string.
+   * @param otherPath - The other pathway or string to resolve against.
+   * @returns A new Pathway instance representing the resolved path.
+   */
+  public resolve(otherPath: Pathway | string | string[]): Pathway {
+    const otherSegments = otherPath instanceof Pathway ? otherPath.getSegments() : this.normalizePath(otherPath);
+    const resolvedSegments = [...this.segments];
+
+    if (otherPath instanceof Pathway ? otherPath.isAbsolute() : (Array.isArray(otherPath) ? otherPath[0].startsWith('/') : otherPath.startsWith('/'))) {
+      return new Pathway(otherSegments);
+    }
+
+    for (const segment of otherSegments) {
+      if (segment === '..') {
+        if (resolvedSegments.length > 0 && resolvedSegments[resolvedSegments.length - 1] !== '..') {
+          resolvedSegments.pop();
+        } else {
+          resolvedSegments.push(segment);
+        }
+      } else if (segment !== '.') {
+        resolvedSegments.push(segment);
+      }
+    }
+
+    return new Pathway(this.isAbsolute() ? ["/", ...resolvedSegments] : resolvedSegments);
+  }
+
+  /**
+   * Gets the parent directory of the current pathway.
+   * @returns A new Pathway instance representing the parent directory.
+   */
+  public getParent(): Pathway {
+    if (this.segments.length === 0) {
+      return new Pathway(null);
+    }
+    const parentSegments = this.segments.slice(0, -1);
+    return new Pathway(this.isAbsolute() ? ["/", ...parentSegments] : parentSegments);
+  }
+
+  /**
+   * Gets the current directory of the pathway.
+   * @returns The current directory as a string.
+   */
+  public getCurrentDirectory(): string {
+    if (this.segments.length === 0) {
+      return '';
+    }
+    return this.segments[this.segments.length - 1];
+  }
+
+  /**
+   * Static method to get the absolute path of the root.
+   * @returns A new Pathway instance representing the root path.
+   */
+  public static ofRoot(): Pathway {
+    return new Pathway('/');
+  }
+
+  /**
+   * Determines the relative path from this pathway to another pathway.
+   * @param otherPath - The other pathway to relativize against.
+   * @returns A new Pathway instance representing the relative path.
+   */
+  public relativize(otherPath: Pathway | string | string[]): Pathway {
+    const otherSegments = otherPath instanceof Pathway ? otherPath.getSegments() : this.normalizePath(otherPath);
+
+    if (this.isAbsolute() !== (otherPath instanceof Pathway ? otherPath.isAbsolute() : (Array.isArray(otherPath) ? otherPath[0].startsWith('/') : otherPath.startsWith('/')))) {
+      throw new Error("Cannot relativize between absolute and relative paths");
+    }
+
+    let commonLength = 0;
+    const maxLength = Math.min(this.segments.length, otherSegments.length);
+    for (let i = 0; i < maxLength; i++) {
+      if (this.segments[i] !== otherSegments[i]) {
+        break;
+      }
+      commonLength++;
+    }
+
+    const upSegments = this.segments.slice(commonLength).map(() => '..');
+    const downSegments = otherSegments.slice(commonLength);
+
+    return new Pathway(upSegments.concat(downSegments));
+  }
+
+  /**
+   * Checks if the given path is a descendant of the current pathway.
+   * @param otherPath - The other pathway to check.
+   * @returns True if the given path is a descendant, false otherwise.
+   */
+  public isDescendant(otherPath: Pathway | string | string[]): boolean {
+    const otherSegments = otherPath instanceof Pathway ? otherPath.getSegments() : this.normalizePath(otherPath);
+
+    if (otherSegments.length < this.segments.length) {
+      return false;
+    }
+
+    for (let i = 0; i < this.segments.length; i++) {
+      if (this.segments[i] !== otherSegments[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+
+  static isRelativePath(path : Path) : boolean {
+    const pathway = typeof path === "object" && !Array.isArray(path) ? path : Pathway.of(path)
+    return pathway.isRelative()
+  }
+
+  static asString(path : Path) : string {
+    if(typeof path === "string"){
+      return path
+    } else {
+      const pathway = typeof path === "object" && !Array.isArray(path)? path : Pathway.of(path)
+      return pathway.toString()
+    }
+  }
+
+  static getName(path: string | string[] | Pathway) {
+    let name: string
+    switch (typeof path) {
+      case "string": {
+        name = path
+      }
+        break
+      case "object": {
+        const segments = Array.isArray(path) ? path : path.getSegments()
+        name = segments[segments.length - 1]
+      }
+        break
+    }
+    return name;
+  }
+
+}

package/tsconfig.es2015.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2015",
+    "lib": [
+      "ES2015"
+    ],
+    "outDir": "./dist/es2015",
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "downlevelIteration": true,
+    "composite": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "allowImportingTsExtensions": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}