@mangos/filepath 1.0.4 → 1.0.6

package/README.md

@@ -37,7 +37,7 @@ _Note: `\` needs to be escaped when using it in js code._
 ```javascript
 // node resolve
 path.resolve('//?/UNC/Server/share', '../../../txt');
-// -> ''\\\\?\\txt''  mangled unc loot
+// -> '\\\\?\\txt'  mangled unc loot
 
 // this library
 filePath.resolve('//?/UNC/Server/share', '../../../txt').toString();
@@ -61,6 +61,12 @@ There are 4 exported functions:
 import { allPath, firstPath, resolve, resolvePathObject } from '@mangos/filepath';
 ```
 
+There are 2 exported classes:
+
+```typescript
+import { ParsedPath,  ParsedPathError } from '@mangos/filepath';
+```
+
 Most of the time you will be using <a href="#fn-resolve"><code>resolve</code></a>, <a href="#fn-first-path"><code>firstPath</code></a>.
 
 <h3 id="infer-path-options">Type <code>InferPathOptions</code></h3>
@@ -96,10 +102,10 @@ An instance of `ParsedPath` has the following fields/members
 
 - members:
     - <code>toString(): <i>string</i></code>: return the original path string
-    - <code>isRelative(): <i>boolean</i></codes>: is the a path a relative one?
+    - <code>isRelative(): <i>boolean</i></code>: is the a path a relative one?
 - fields:
     - <code>type: <i>string</i></code>: one of the value `devicePath`, `unc`, `dos`, `posix`.
-    - <code>path: <i>Token[]</i></code>: the path tokenized (see source).
+    - <code>path: <i>FileToken[]</i></code>: the path tokenized (see source).
 
 <h3 id="parsed-path-error"><code>ParsedPathError</code> object</h3>
 
@@ -109,7 +115,7 @@ If a path has illigal characters or is invalid the result of a tokenization will
     - <code>toString(): <i>string</i></code>: algamation of all errors found during parsing.
 - attributes:
     - <code>type: <i>string</i></code>: one of the values `devicePath`, `unc`, `dos`, `posix`.
-    - <code>path: <i>Token[]</i></code>: the path tokenized.
+    - <code>path: <i>FileToken[]</i></code>: the path tokenized.
 
 
 <h3 id="path-type-order-of-evaluation">Path type order of evaluation</h4>
@@ -179,7 +185,7 @@ function firstPath(path = '', options: InferPathOptions = {}): ParsedPath | Pars
 <h4 id="fn-resolve-path-object">function: <code>resolvePathObject</code></h4>
 
 ```typescript
-function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPath | ParsedPathError;
+function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPath;
 ```
 
 <h5 id="fn-resolve-path-object-arguments">Arguments:</h5>
@@ -190,16 +196,16 @@ function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPa
 <h5 id="fn-resolve-path-object-return">Return:</h5>
 
 - <a href="#parsed-path"><code>ParsedPath</code></a>: In case of successfull resolve.
-- <a href="#parsed-path-error"><code>ParsedPathError</code></a>: In case of legal structure but illegal characters in the `from` or `toFragments`.
 
 <h5 id="fn-resolve-path-object-throws">throws:</h5>
 
-If <code>from</code> is a <a href="#parsed-path-error"><code>ParsedPathError</code></a> an `Error` will be thrown.
+- If <code>from</code> is a <a href="#parsed-path-error"><code>ParsedPathError</code></a> an `Error` will be thrown.
+- If any of the `toFragments` is an invalid path an Error will be thrown.
 
 <h4 id="fn-resolve">function: <code>resolve</code></h4>
 
 ```typescript
-function resolve(fromStr: string, ...toFragments: string[]): ParsedPath | ParsedPathError;
+function resolve(fromStr: string, ...toFragments: string[]): ParsedPath;
 ```
 
 <h5 id="fn-resolve-arguments">Arguments:</h5>
@@ -210,11 +216,10 @@ function resolve(fromStr: string, ...toFragments: string[]): ParsedPath | Parsed
 <h5 id="fn-resolve-return">Return:</h5>
 
 - <a href="#parsed-path"><code>ParsedPath</code></a>: In case of successfull resolve.
-- <a href="#parsed-path-error"><code>ParsedPathError</code></a>: In case of legal structure but illegal characters in the `from` or `toFragments`.
 
 <h5 id="fn-resolve-throws">throws:</h5>
 
-If <code>fromStr</code> is a <a href="#parsed-path-error"><code>ParsedPathError</code></a> an `Error` will be thrown.
+If <code>fromStr</code> is invalid a <a href="#parsed-path-error"><code>ParsedPathError</code></a> an `Error` will be thrown.
 
 <h2>License</h2>
 

package/dist/ParsedPath.d.ts

@@ -1,7 +1,7 @@
 import type { FileSystem, ParsedPathDTO } from './parser.js';
-import type { Token } from './Token.js';
+import type { PathToken } from './Token.js';
 export declare class ParsedPath {
-    readonly path: Token[];
+    readonly path: PathToken[];
     readonly type: FileSystem;
     constructor(parsed: ParsedPathDTO);
     toString(): string;

package/dist/ParsedPathError.d.ts

@@ -1,8 +1,8 @@
-import type { Token } from 'Token.js';
+import type { PathToken } from 'Token.js';
 import type { FileSystem, ParsedPathDTO } from './parser.js';
 export declare class ParsedPathError {
     private readonly parsed;
-    readonly path: Token[];
+    readonly path: PathToken[];
     readonly type: FileSystem;
     constructor(parsed: ParsedPathDTO);
     toString(): string;

package/dist/Token.d.ts

@@ -1,18 +1,18 @@
-import type { TokenValueType } from './types/TokenValueType.js';
-export declare class Token {
-    readonly token: TokenValueType;
+import type { PathTokenValueType } from './types/TokenValueType.js';
+export declare class PathToken {
+    readonly token: PathTokenValueType;
     readonly value: string;
     readonly start: number;
     readonly end: number;
     static from(o: {
-        token: TokenValueType;
+        token: PathTokenValueType;
         value: string;
         start: number;
         end: number;
         error?: string;
-    }): Token;
+    }): PathToken;
     readonly error?: string;
-    constructor(token: TokenValueType, value: string, start: number, end: number, error?: string);
+    constructor(token: PathTokenValueType, value: string, start: number, end: number, error?: string);
     isRoot(): boolean;
-    equals(ot: Token): boolean;
+    equals(ot: PathToken): boolean;
 }

package/dist/Token.js

@@ -1,5 +1,5 @@
-import { TokenEnum } from "./constants.js";
-class Token {
+import { PathTokenEnum } from "./constants.js";
+class PathToken {
   constructor(token, value, start, end, error) {
     this.token = token;
     this.value = value;
@@ -10,16 +10,16 @@ class Token {
     }
   }
   static from(o) {
-    return new Token(o.token, o.value, o.start, o.end, o.error);
+    return new PathToken(o.token, o.value, o.start, o.end, o.error);
   }
   error;
   isRoot() {
-    return this.token === TokenEnum.ROOT;
+    return this.token === PathTokenEnum.ROOT;
   }
   equals(ot) {
-    return ot.token === this.token && ot.value === this.value && ot.start === this.start && ot.end === this.end && ot.error === this.error;
+    return ot.token === this.token && ot.value === this.value && ot.error === this.error;
   }
 }
 export {
-  Token
+  PathToken
 };

package/dist/absorbers/ddp.d.ts

@@ -1,4 +1,4 @@
-import { Token } from '../Token.js';
+import { PathToken } from '../Token.js';
 type RegExporderdMapDDP = {
     ddpwithUNC: RegExp;
     ddpwithVolumeUUID: RegExp;
@@ -6,5 +6,5 @@ type RegExporderdMapDDP = {
     unc?: RegExp;
 };
 export declare const regExpOrderedMapDDP: RegExporderdMapDDP;
-export declare function ddpAbsorber(str?: string, start?: number, end?: number): Generator<Token, undefined, undefined>;
+export declare function ddpAbsorber(str?: string, start?: number, end?: number): Generator<PathToken, undefined, undefined>;
 export {};

package/dist/absorbers/ddp.js

@@ -1,5 +1,5 @@
-import { TokenEnum } from "../constants.js";
-import { Token } from "../Token.js";
+import { PathTokenEnum } from "../constants.js";
+import { PathToken } from "../Token.js";
 import { tdpBodyAbsorber } from "./tdp.js";
 const regExpOrderedMapDDP = {
   //  \\?\UNC\Server\Share\
@@ -24,7 +24,7 @@ const createRootValueMap = {
   }
 };
 function createRootToken(value, offset = 0) {
-  return new Token(TokenEnum.ROOT, value, offset, offset + value.length - 1);
+  return new PathToken(PathTokenEnum.ROOT, value, offset, offset + value.length - 1);
 }
 function* ddpAbsorber(str = "", start = 0, end = str.length - 1) {
   const pks = Object.keys(regExpOrderedMapDDP);

package/dist/absorbers/posix.d.ts

@@ -1,2 +1,2 @@
-import { Token } from '../Token.js';
-export default function posixAbsorber(str?: string, start?: number, end?: number): Generator<Token, undefined, undefined>;
+import { PathToken } from '../Token.js';
+export default function posixAbsorber(str?: string, start?: number, end?: number): Generator<PathToken, undefined, undefined>;

package/dist/absorbers/posix.js

@@ -1,12 +1,12 @@
 import absorbSuccessiveValues from "../absorbSuccessiveValues.js";
-import { TokenEnum } from "../constants.js";
-import { Token } from "../Token.js";
+import { PathTokenEnum } from "../constants.js";
+import { PathToken } from "../Token.js";
 import { togglePathFragment } from "../togglePathFragment.js";
 function* posixAbsorber(str = "", start = 0, end = str.length - 1) {
   let i = start;
   const root = absorbSuccessiveValues(str, (s) => s === "/", start, end);
   if (root) {
-    yield new Token(TokenEnum.ROOT, str.slice(start, root.end + 1), start, root.end);
+    yield new PathToken(PathTokenEnum.ROOT, str.slice(start, root.end + 1), start, root.end);
     i = root.end + 1;
   }
   let toggle = 0;
@@ -17,12 +17,12 @@ function* posixAbsorber(str = "", start = 0, end = str.length - 1) {
       const value = str.slice(i, result.end + 1);
       let token = togglePathFragment[toggle % 2];
       if (value === "..") {
-        token = TokenEnum.PARENT;
+        token = PathTokenEnum.PARENT;
       }
       if (value === ".") {
-        token = TokenEnum.CURRENT;
+        token = PathTokenEnum.CURRENT;
       }
-      yield new Token(token, value, result.start, result.end);
+      yield new PathToken(token, value, result.start, result.end);
       i = result.end + 1;
     }
     toggle = ++toggle % 2;

package/dist/absorbers/tdp.d.ts

@@ -1,3 +1,3 @@
-import { Token } from '../Token.js';
-export default function tdpAbsorber(str?: string): Generator<Token, undefined, undefined>;
-export declare function tdpBodyAbsorber(str: string | undefined, start: number, end?: number): Generator<Token, undefined, undefined>;
+import { PathToken } from '../Token.js';
+export default function tdpAbsorber(str?: string): Generator<PathToken, undefined, undefined>;
+export declare function tdpBodyAbsorber(str: string | undefined, start: number, end?: number): Generator<PathToken, undefined, undefined>;

package/dist/absorbers/tdp.js

@@ -1,9 +1,9 @@
 import absorbSuccessiveValues from "../absorbSuccessiveValues.js";
-import { TokenEnum } from "../constants.js";
+import { PathTokenEnum } from "../constants.js";
 import getCWD from "../getCWD.js";
 import getDrive from "../getDrive.js";
 import mapPlatformNames from "../platform.js";
-import { Token } from "../Token.js";
+import { PathToken } from "../Token.js";
 import { togglePathFragment } from "../togglePathFragment.js";
 import validSep from "../validSep.js";
 import { regExpOrderedMapDDP, ddpAbsorber } from "./ddp.js";
@@ -37,7 +37,7 @@ function getCWDDOSRoot() {
   }
   const drive = getDrive(getCWD());
   if (drive[0] >= "a" && drive[0] <= "z" && drive[1] === ":") {
-    return new Token(TokenEnum.ROOT, `${drive.join("")}`, 0, 1);
+    return new PathToken(PathTokenEnum.ROOT, `${drive.join("")}`, 0, 1);
   }
   return void 0;
 }
@@ -73,8 +73,8 @@ function* tdpAbsorber(str = "") {
       }
     }
     const value = str.slice(result.start, result.end + 1);
-    yield new Token(
-      TokenEnum.PATHELT,
+    yield new PathToken(
+      PathTokenEnum.PATHELT,
       value,
       0,
       result.end,
@@ -87,7 +87,7 @@ function* tdpAbsorber(str = "") {
   }
   const drive = getDrive(str.slice(i, i + 2).toLowerCase());
   if (drive[0] >= "a" && drive[0] <= "z" && drive[1] === ":") {
-    yield new Token(TokenEnum.ROOT, `${drive.join("")}`, i, i + 1);
+    yield new PathToken(PathTokenEnum.ROOT, `${drive.join("")}`, i, i + 1);
     i = 2;
   }
   yield* tdpBodyAbsorber(str, i, str.length - 1);
@@ -104,10 +104,10 @@ function* tdpBodyAbsorber(str = "", start, end = str.length - 1) {
       if (toggle === 0) {
         switch (value) {
           case "..":
-            token = TokenEnum.PARENT;
+            token = PathTokenEnum.PARENT;
             break;
           case ".":
-            token = TokenEnum.CURRENT;
+            token = PathTokenEnum.CURRENT;
             break;
           default: {
             const ldn = hasLegacyDeviceName(value);
@@ -120,7 +120,7 @@ function* tdpBodyAbsorber(str = "", start, end = str.length - 1) {
           }
         }
       }
-      yield errors?.length ? new Token(token, value, result.start, result.end, errors?.join("|")) : new Token(token, value, result.start, result.end);
+      yield errors?.length ? new PathToken(token, value, result.start, result.end, errors?.join("|")) : new PathToken(token, value, result.start, result.end);
       i = result.end + 1;
     }
     toggle = ++toggle % 2;

package/dist/absorbers/unc.d.ts

@@ -1,3 +1,3 @@
-import { Token } from '../Token.js';
+import { PathToken } from '../Token.js';
 export declare const uncRegExp: RegExp;
-export default function uncAbsorber(str?: string): Generator<Token, undefined, undefined>;
+export default function uncAbsorber(str?: string): Generator<PathToken, undefined, undefined>;

package/dist/absorbers/unc.js

@@ -1,5 +1,5 @@
-import { TokenEnum } from "../constants.js";
-import { Token } from "../Token.js";
+import { PathTokenEnum } from "../constants.js";
+import { PathToken } from "../Token.js";
 import { tdpBodyAbsorber } from "./tdp.js";
 const uncRegExp = /^(\/\/|\\\\)([^\\/\\?\\.]+)(\/|\\)([^\\/]+)(\/|\\)?/;
 function* uncAbsorber(str = "") {
@@ -11,7 +11,7 @@ function* uncAbsorber(str = "") {
   const share = match[4];
   const value = `\\\\${server}\\${share}`;
   const endUnc = value.length - 1;
-  yield new Token(TokenEnum.ROOT, value, 0, endUnc);
+  yield new PathToken(PathTokenEnum.ROOT, value, 0, endUnc);
   yield* tdpBodyAbsorber(str, endUnc + 1, str.length - 1);
 }
 export {

package/dist/constants.d.ts

@@ -1,11 +1,11 @@
-export declare const TokenEnum: {
+export declare const PathTokenEnum: {
     readonly SEP: "\u0001";
     readonly ROOT: "\u0003";
     readonly PATHELT: "\u0006";
     readonly PARENT: "\u0007";
     readonly CURRENT: "\b";
 };
-export type TokenValueEnumType = {
-    -readonly [K in keyof typeof TokenEnum as (typeof TokenEnum)[K]]: K;
+export type PathTokenValueEnumType = {
+    -readonly [K in keyof typeof PathTokenEnum as (typeof PathTokenEnum)[K]]: K;
 };
-export declare const TokenValueEnum: TokenValueEnumType;
+export declare const TokenValueEnum: PathTokenValueEnumType;

package/dist/constants.js

@@ -1,4 +1,4 @@
-const TokenEnum = {
+const PathTokenEnum = {
   SEP: "
",
   ROOT: "",
   PATHELT: "",
@@ -6,12 +6,12 @@ const TokenEnum = {
   CURRENT: "\b"
 };
 (() => {
-  const entries = Object.entries(TokenEnum);
+  const entries = Object.entries(PathTokenEnum);
   return entries.reduce((obj, [prop, value]) => {
     obj[value] = prop;
     return obj;
   }, {});
 })();
 export {
-  TokenEnum
+  PathTokenEnum
 };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { allPath, firstPath, resolve } from './parser.js';
-import type { Token } from './Token.js';
-import type { TokenValueType } from './types/TokenValueType.js';
-export { resolve, firstPath, allPath, type Token };
-export type { TokenValueType };
+import { ParsedPath } from './ParsedPath.js';
+import { ParsedPathError } from './ParsedPathError.js';
+import { allPath, firstPath, resolve, resolvePathObject } from './parser.js';
+import type { PathToken } from './Token.js';
+import type { PathTokenValueType } from './types/TokenValueType.js';
+export { resolve, firstPath, allPath, ParsedPath, ParsedPathError, resolvePathObject };
+export type { PathTokenValueType, PathToken };

package/dist/index.js

@@ -1,6 +1,11 @@
-import { allPath, firstPath, resolve } from "./parser.js";
+import { ParsedPath } from "./ParsedPath.js";
+import { ParsedPathError } from "./ParsedPathError.js";
+import { allPath, firstPath, resolve, resolvePathObject } from "./parser.js";
 export {
+  ParsedPath,
+  ParsedPathError,
   allPath,
   firstPath,
-  resolve
+  resolve,
+  resolvePathObject
 };

package/dist/parser.d.ts

@@ -1,17 +1,17 @@
 import { ParsedPath } from './ParsedPath.js';
 import { ParsedPathError } from './ParsedPathError.js';
-import { Token } from './Token.js';
+import { PathToken } from './Token.js';
 export type FileSystem = 'devicePath' | 'unc' | 'dos' | 'posix';
 declare function firstPath(path?: string, options?: InferPathOptions): ParsedPath | ParsedPathError | undefined;
 declare function allPath(path?: string, options?: InferPathOptions): (ParsedPath | ParsedPathError)[];
 export type ParsedPathDTO = {
     type: FileSystem;
-    path: Token[];
+    path: PathToken[];
     firstError?: number;
 };
-declare function resolve(fromStr?: string, ...toFragments: string[]): ParsedPath | ParsedPathError;
-declare function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPath | ParsedPathError;
+declare function resolve(fromStr?: string, ...toFragments: string[]): ParsedPath;
+declare function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPath;
 type InferPathOptions = {
     [key in FileSystem]+?: boolean;
 };
-export { resolve, type resolvePathObject, firstPath, allPath };
+export { resolve, resolvePathObject, firstPath, allPath };

package/dist/parser.js

@@ -2,12 +2,12 @@ import { ddpAbsorber } from "./absorbers/ddp.js";
 import posixAbsorber from "./absorbers/posix.js";
 import tdpAbsorber from "./absorbers/tdp.js";
 import uncAbsorber from "./absorbers/unc.js";
-import { TokenEnum } from "./constants.js";
+import { PathTokenEnum } from "./constants.js";
 import getCWD from "./getCWD.js";
 import { ParsedPath } from "./ParsedPath.js";
 import { ParsedPathError } from "./ParsedPathError.js";
 import mapPlatformNames from "./platform.js";
-import { Token } from "./Token.js";
+import { PathToken } from "./Token.js";
 const absorberMapping = {
   unc: uncAbsorber,
   dos: tdpAbsorber,
@@ -16,6 +16,9 @@ const absorberMapping = {
 };
 const allNamespaces = ["devicePath", "unc", "dos", "posix"];
 function firstPath(path = "", options = {}) {
+  if (path === "") {
+    return void 0;
+  }
   const iterator = inferPathType(path, options);
   const step = iterator.next();
   if (step.done) {
@@ -54,7 +57,7 @@ function last(arr) {
 }
 function upp(path) {
   let _last;
-  for (_last = last(path); _last.token === TokenEnum.SEP; _last = last(path)) {
+  for (_last = last(path); _last.token === PathTokenEnum.SEP; _last = last(path)) {
     path.pop();
   }
   if (_last !== path[0]) {
@@ -62,15 +65,15 @@ function upp(path) {
   }
 }
 function add(_tokens, token) {
-  if (token.token === TokenEnum.SEP) {
+  if (token.token === PathTokenEnum.SEP) {
     return;
   }
   let _last = last(_tokens);
-  for (; _last.token === TokenEnum.SEP; _last = last(_tokens)) {
+  for (; _last.token === PathTokenEnum.SEP; _last = last(_tokens)) {
     _tokens.pop();
   }
-  _tokens.push(new Token(TokenEnum.SEP, getSeperator(), _last.end + 1, _last.end + 1));
-  _tokens.push(new Token(token.token, token.value, _last.end + 2, _last.end + 2 + token.end));
+  _tokens.push(new PathToken(PathTokenEnum.SEP, getSeperator(), _last.end + 1, _last.end + 1));
+  _tokens.push(new PathToken(token.token, token.value, _last.end + 2, _last.end + 2 + token.end));
 }
 function firstPathFromCWD() {
   return firstPath(getCWD());
@@ -107,13 +110,13 @@ function resolvePathObject(from, ...toFragments) {
   const working = structuredClone(from.path);
   for (const token of firstPathTo.path) {
     switch (token.token) {
-      case TokenEnum.SEP:
-      case TokenEnum.CURRENT:
+      case PathTokenEnum.SEP:
+      case PathTokenEnum.CURRENT:
         break;
-      case TokenEnum.PARENT:
+      case PathTokenEnum.PARENT:
         upp(working);
         break;
-      case TokenEnum.PATHELT:
+      case PathTokenEnum.PATHELT:
         add(working, token);
         break;
     }
@@ -157,5 +160,6 @@ function* inferPathType(path, options = {}) {
 export {
   allPath,
   firstPath,
-  resolve
+  resolve,
+  resolvePathObject
 };

package/dist/togglePathFragment.js

@@ -1,5 +1,5 @@
-import { TokenEnum } from "./constants.js";
-const togglePathFragment = [TokenEnum.PATHELT, TokenEnum.SEP];
+import { PathTokenEnum } from "./constants.js";
+const togglePathFragment = [PathTokenEnum.PATHELT, PathTokenEnum.SEP];
 export {
   togglePathFragment
 };

package/dist/types/TokenValueType.d.ts

@@ -1,2 +1,2 @@
-import type { TokenEnum } from '../constants';
-export type TokenValueType = (typeof TokenEnum)[keyof typeof TokenEnum];
+import type { PathTokenEnum } from '../constants';
+export type PathTokenValueType = (typeof PathTokenEnum)[keyof typeof PathTokenEnum];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mangos/filepath",
-	"version": "1.0.4",
+	"version": "1.0.6",
 	"author": "jacob bogers <jkfbogers@gmail.com>",
 	"repository": {
 		"type": "git",
@@ -17,7 +17,7 @@
 	"main": "./dist/index.js",
 	"devDependencies": {
 		"@biomejs/biome": "^2.3.8",
-		"@types/node": "^25.0.0",
+		"@types/node": "^25.0.3",
 		"@vitest/coverage-v8": "^4.0.15",
 		"typescript": "^5.9.3",
 		"vite": "^7.2.7",