@mangos/filepath 1.0.8 → 1.0.9

package/README.md

@@ -67,12 +67,6 @@ There are 2 exported classes:
 import { ParsedPath,  ParsedPathError, PathToken } from '@mangos/filepath';
 ```
 
-There is 1 exported enum:
-
-```typescript
-import { PathTokenEnum } from '@mangos/filepath'
-```
-
 There is 1 exported type:
 
 ```typescript
@@ -145,7 +139,6 @@ You dont create `PathToken`s yourself the api will do it for you.
 
 ```typescript
 class PathToken {
-    token: PathTokenValueType;
 	value: string; // actual path fragment (directory, seperator, or file)
 	start: number; // start location in the original string
 	end: number; // end (inclusive) in the original string
@@ -155,21 +148,10 @@ class PathToken {
     isCurrent(): boolean; // token representing "./"
     isParent(): boolean // token representing "../"
     isSeperator(): boolean // token representing "/" (posix) or "\" (windows, dos)
+    hasError(): boolean // did tokenizing the path associated an error with this token
 }
 ```
 
-The `PathTokenValueType` match the exported `PathTokenEnum` object
-
-```typescript
-export const PathTokenEnum = {
-	SEP: '\x01',       // path seperator
-	ROOT: '\x03',      // the root (if it is an absolute path)
-	PATHELT: '\x06',   // directory, file, 
-	PARENT: '\x07',    // two dots (..) meaning parent directory
-	CURRENT: '\x08',   // a single dot (.) meaning current directory
-} as const;
-```
-
 <h3 id="api-functions">Functions</h3>
 
 <h4 id="fn-all-path">function: <code>allPath</code></h4>

package/dist/ParsedPath.d.ts

@@ -1,9 +1,14 @@
-import type { FileSystem, ParsedPathDTO } from './parser.js';
-import type { PathToken } from './Token.js';
+import type { FileSystem, ParsedPathInputDTO } from './parser.js';
+import type { PathToken, PathTokenDTO } from './types/PathToken.js';
 export declare class ParsedPath {
     readonly path: PathToken[];
     readonly type: FileSystem;
-    constructor(parsed: ParsedPathDTO);
+    constructor(parsed: ParsedPathInputDTO);
     toString(): string;
     isRelative(): boolean;
+    toDTO(): ParsedPathDTO;
 }
+export type ParsedPathDTO = {
+    type: FileSystem;
+    path: PathTokenDTO[];
+};

package/dist/ParsedPath.js

@@ -11,6 +11,12 @@ class ParsedPath {
   isRelative() {
     return this.path[0].isRoot() === false;
   }
+  toDTO() {
+    return {
+      type: this.type,
+      path: this.path.map((pt) => pt.toDTO())
+    };
+  }
 }
 export {
   ParsedPath

package/dist/ParsedPathError.d.ts

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

package/dist/ParsedPathError.js

@@ -14,6 +14,12 @@ class ParsedPathError {
       return "";
     }).join("\n");
   }
+  toDTO() {
+    return {
+      type: this.type,
+      path: this.path.map((pt) => pt.toDTO())
+    };
+  }
 }
 export {
   ParsedPathError

package/dist/PathTokenImpl.d.ts

@@ -0,0 +1,28 @@
+import { PathTokenEnum } from './constants.js';
+import type { PathToken, PathTokenDTO } from './types/PathToken.js';
+import type { PathTokenValueType } from './types/TokenValueType.js';
+export declare class PathTokenImpl implements PathToken {
+    #private;
+    static from(o: {
+        type: keyof typeof PathTokenEnum;
+        value: string;
+        start: number;
+        end: number;
+        error?: string | undefined;
+    }): PathTokenImpl;
+    constructor(token: PathTokenValueType, value: string, start: number, end: number, error?: string);
+    isRoot(): boolean;
+    isSeparator(): boolean;
+    isPathElement(): boolean;
+    isCurrent(): boolean;
+    isParent(): boolean;
+    equals(ot: PathToken): boolean;
+    hasError(): boolean;
+    get type(): PathTokenValueType;
+    get error(): string | undefined;
+    get value(): string;
+    get end(): number;
+    get start(): number;
+    clone(): PathTokenImpl;
+    toDTO(): PathTokenDTO;
+}

package/dist/PathTokenImpl.js

@@ -0,0 +1,71 @@
+import { PathTokenEnum, TokenValueEnum } from "./constants.js";
+class PathTokenImpl {
+  static from(o) {
+    return new PathTokenImpl(PathTokenEnum[o.type], o.value, o.start, o.end, o.error);
+  }
+  constructor(token, value, start, end, error) {
+    this.#token = token;
+    this.#value = value;
+    this.#end = end;
+    this.#start = start;
+    if (error) {
+      this.#error = error;
+    }
+  }
+  isRoot() {
+    return this.#token === PathTokenEnum.ROOT;
+  }
+  isSeparator() {
+    return this.#token === PathTokenEnum.SEP;
+  }
+  isPathElement() {
+    return this.#token === PathTokenEnum.PATHELT;
+  }
+  isCurrent() {
+    return this.#token === PathTokenEnum.CURRENT;
+  }
+  isParent() {
+    return this.#token === PathTokenEnum.PARENT;
+  }
+  equals(ot) {
+    return ot.type === this.type && ot.value === this.value && ot.error === this.error;
+  }
+  hasError() {
+    return !!this.error;
+  }
+  get type() {
+    return this.#token;
+  }
+  get error() {
+    return this.#error;
+  }
+  get value() {
+    return this.#value;
+  }
+  get end() {
+    return this.#end;
+  }
+  get start() {
+    return this.#start;
+  }
+  clone() {
+    return new PathTokenImpl(this.#token, this.#value, this.#start, this.#end, this.#error);
+  }
+  toDTO() {
+    return {
+      type: TokenValueEnum[this.#token],
+      ...this.#error && { error: this.#error },
+      value: this.#value,
+      end: this.#end,
+      start: this.#start
+    };
+  }
+  #error;
+  #token;
+  #value;
+  #end;
+  #start;
+}
+export {
+  PathTokenImpl
+};

package/dist/absorbers/ddp.d.ts

@@ -1,4 +1,4 @@
-import { PathToken } from '../Token.js';
+import { PathTokenImpl } from '../PathTokenImpl.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<PathToken, undefined, undefined>;
+export declare function ddpAbsorber(str?: string, start?: number, end?: number): Generator<PathTokenImpl, undefined, undefined>;
 export {};

package/dist/absorbers/ddp.js

@@ -1,5 +1,5 @@
 import { PathTokenEnum } from "../constants.js";
-import { PathToken } from "../Token.js";
+import { PathTokenImpl } from "../PathTokenImpl.js";
 import { tdpBodyAbsorber } from "./tdp.js";
 const regExpOrderedMapDDP = {
   //  \\?\UNC\Server\Share\
@@ -24,7 +24,7 @@ const createRootValueMap = {
   }
 };
 function createRootToken(value, offset = 0) {
-  return new PathToken(PathTokenEnum.ROOT, value, offset, offset + value.length - 1);
+  return new PathTokenImpl(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 { PathToken } from '../Token.js';
-export default function posixAbsorber(str?: string, start?: number, end?: number): Generator<PathToken, undefined, undefined>;
+import { PathTokenImpl } from '../PathTokenImpl.js';
+export default function posixAbsorber(str?: string, start?: number, end?: number): Generator<PathTokenImpl, undefined, undefined>;

package/dist/absorbers/posix.js

@@ -1,12 +1,12 @@
 import absorbSuccessiveValues from "../absorbSuccessiveValues.js";
 import { PathTokenEnum } from "../constants.js";
-import { PathToken } from "../Token.js";
+import { PathTokenImpl } from "../PathTokenImpl.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 PathToken(PathTokenEnum.ROOT, str.slice(start, root.end + 1), start, root.end);
+    yield new PathTokenImpl(PathTokenEnum.ROOT, str.slice(start, root.end + 1), start, root.end);
     i = root.end + 1;
   }
   let toggle = 0;
@@ -22,7 +22,7 @@ function* posixAbsorber(str = "", start = 0, end = str.length - 1) {
       if (value === ".") {
         token = PathTokenEnum.CURRENT;
       }
-      yield new PathToken(token, value, result.start, result.end);
+      yield new PathTokenImpl(token, value, result.start, result.end);
       i = result.end + 1;
     }
     toggle = ++toggle % 2;

package/dist/absorbers/tdp.d.ts

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

package/dist/absorbers/tdp.js

@@ -2,8 +2,8 @@ import absorbSuccessiveValues from "../absorbSuccessiveValues.js";
 import { PathTokenEnum } from "../constants.js";
 import getCWD from "../getCWD.js";
 import getDrive from "../getDrive.js";
+import { PathTokenImpl } from "../PathTokenImpl.js";
 import mapPlatformNames from "../platform.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 PathToken(PathTokenEnum.ROOT, `${drive.join("")}`, 0, 1);
+    return new PathTokenImpl(PathTokenEnum.ROOT, `${drive.join("")}`, 0, 1);
   }
   return void 0;
 }
@@ -73,7 +73,7 @@ function* tdpAbsorber(str = "") {
       }
     }
     const value = str.slice(result.start, result.end + 1);
-    yield new PathToken(
+    yield new PathTokenImpl(
       PathTokenEnum.PATHELT,
       value,
       0,
@@ -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 PathToken(PathTokenEnum.ROOT, `${drive.join("")}`, i, i + 1);
+    yield new PathTokenImpl(PathTokenEnum.ROOT, `${drive.join("")}`, i, i + 1);
     i = 2;
   }
   yield* tdpBodyAbsorber(str, i, str.length - 1);
@@ -120,7 +120,7 @@ function* tdpBodyAbsorber(str = "", start, end = str.length - 1) {
           }
         }
       }
-      yield errors?.length ? new PathToken(token, value, result.start, result.end, errors?.join("|")) : new PathToken(token, value, result.start, result.end);
+      yield errors?.length ? new PathTokenImpl(token, value, result.start, result.end, errors?.join("|")) : new PathTokenImpl(token, value, result.start, result.end);
       i = result.end + 1;
     }
     toggle = ++toggle % 2;

package/dist/absorbers/unc.d.ts

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

package/dist/absorbers/unc.js

@@ -1,5 +1,5 @@
 import { PathTokenEnum } from "../constants.js";
-import { PathToken } from "../Token.js";
+import { PathTokenImpl } from "../PathTokenImpl.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 PathToken(PathTokenEnum.ROOT, value, 0, endUnc);
+  yield new PathTokenImpl(PathTokenEnum.ROOT, value, 0, endUnc);
   yield* tdpBodyAbsorber(str, endUnc + 1, str.length - 1);
 }
 export {

package/dist/constants.js

@@ -5,7 +5,7 @@ const PathTokenEnum = {
   PARENT: "\x07",
   CURRENT: "\b"
 };
-(() => {
+const TokenValueEnum = (() => {
   const entries = Object.entries(PathTokenEnum);
   return entries.reduce((obj, [prop, value]) => {
     obj[value] = prop;
@@ -13,5 +13,6 @@ const PathTokenEnum = {
   }, {});
 })();
 export {
-  PathTokenEnum
+  PathTokenEnum,
+  TokenValueEnum
 };

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,13 +1,11 @@
-import { PathTokenEnum } from "./constants.js";
 import { ParsedPath } from "./ParsedPath.js";
 import { ParsedPathError } from "./ParsedPathError.js";
+import { PathTokenImpl } from "./PathTokenImpl.js";
 import { allPath, firstPath, resolve, resolvePathObject } from "./parser.js";
-import { PathToken } from "./Token.js";
 export {
   ParsedPath,
   ParsedPathError,
-  PathToken,
-  PathTokenEnum,
+  PathTokenImpl,
   allPath,
   firstPath,
   resolve,

package/dist/parser.d.ts

@@ -1,10 +1,10 @@
 import { ParsedPath } from './ParsedPath.js';
 import { ParsedPathError } from './ParsedPathError.js';
-import { PathToken } from './Token.js';
+import type { PathToken } from './types/PathToken.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 = {
+export type ParsedPathInputDTO = {
     type: FileSystem;
     path: PathToken[];
     firstError?: number;

package/dist/parser.js

@@ -6,8 +6,8 @@ import { PathTokenEnum } from "./constants.js";
 import getCWD from "./getCWD.js";
 import { ParsedPath } from "./ParsedPath.js";
 import { ParsedPathError } from "./ParsedPathError.js";
+import { PathTokenImpl } from "./PathTokenImpl.js";
 import mapPlatformNames from "./platform.js";
-import { PathToken } from "./Token.js";
 const absorberMapping = {
   unc: uncAbsorber,
   dos: tdpAbsorber,
@@ -57,7 +57,7 @@ function last(arr) {
 }
 function upp(path) {
   let _last;
-  for (_last = last(path); _last.token === PathTokenEnum.SEP; _last = last(path)) {
+  for (_last = last(path); _last.isSeparator(); _last = last(path)) {
     path.pop();
   }
   if (_last !== path[0]) {
@@ -65,15 +65,15 @@ function upp(path) {
   }
 }
 function add(_tokens, token) {
-  if (token.token === PathTokenEnum.SEP) {
+  if (token.isSeparator()) {
     return;
   }
   let _last = last(_tokens);
-  for (; _last.token === PathTokenEnum.SEP; _last = last(_tokens)) {
+  for (; _last.type === PathTokenEnum.SEP; _last = last(_tokens)) {
     _tokens.pop();
   }
-  _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));
+  _tokens.push(new PathTokenImpl(PathTokenEnum.SEP, getSeperator(), _last.end + 1, _last.end + 1));
+  _tokens.push(new PathTokenImpl(token.type, token.value, _last.end + 2, _last.end + 2 + token.end));
 }
 function firstPathFromCWD() {
   return firstPath(getCWD());
@@ -107,16 +107,16 @@ function resolvePathObject(from, ...toFragments) {
     }
     return resolvePathObject(firstPathTo, ...toFragments);
   }
-  const working = structuredClone(from.path);
+  const working = from.path.map((s) => s.clone());
   for (const token of firstPathTo.path) {
-    switch (token.token) {
-      case PathTokenEnum.SEP:
-      case PathTokenEnum.CURRENT:
+    switch (true) {
+      case token.isSeparator():
+      case token.isCurrent():
         break;
-      case PathTokenEnum.PARENT:
+      case token.isParent():
         upp(working);
         break;
-      case PathTokenEnum.PATHELT:
+      case token.isPathElement():
         add(working, token);
         break;
     }

package/dist/types/PathToken.d.ts

@@ -0,0 +1,26 @@
+import type { PathTokenEnum } from '../constants.js';
+import type { Token } from './Token';
+import type { PathTokenValueType } from './TokenValueType.js';
+export interface PathToken extends Token {
+    isRoot(): boolean;
+    isSeparator(): boolean;
+    isPathElement(): boolean;
+    isCurrent(): boolean;
+    isParent(): boolean;
+    equals(ot: PathToken): boolean;
+    hasError(): boolean;
+    get error(): undefined | string;
+    get type(): PathTokenValueType;
+    get value(): string;
+    get end(): number;
+    get start(): number;
+    clone(): PathToken;
+    toDTO(): PathTokenDTO;
+}
+export type PathTokenDTO = {
+    type: keyof typeof PathTokenEnum;
+    error?: undefined | string;
+    value: string;
+    end: number;
+    start: number;
+};

package/dist/types/Token.d.ts

@@ -0,0 +1,3 @@
+export interface Token {
+    equals(a: Token): boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mangos/filepath",
-	"version": "1.0.8",
+	"version": "1.0.9",
 	"author": "jacob bogers <jkfbogers@gmail.com>",
 	"repository": {
 		"type": "git",

package/dist/Token.d.ts

@@ -1,22 +0,0 @@
-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: PathTokenValueType;
-        value: string;
-        start: number;
-        end: number;
-        error?: string;
-    }): PathToken;
-    readonly error?: string;
-    constructor(token: PathTokenValueType, value: string, start: number, end: number, error?: string);
-    isRoot(): boolean;
-    isSeparator(): boolean;
-    isPathElement(): boolean;
-    isCurrent(): boolean;
-    isParent(): boolean;
-    equals(ot: PathToken): boolean;
-}

package/dist/Token.js

@@ -1,37 +0,0 @@
-import { PathTokenEnum } from "./constants.js";
-class PathToken {
-  constructor(token, value, start, end, error) {
-    this.token = token;
-    this.value = value;
-    this.start = start;
-    this.end = end;
-    if (error) {
-      this.error = error;
-    }
-  }
-  static from(o) {
-    return new PathToken(o.token, o.value, o.start, o.end, o.error);
-  }
-  error;
-  isRoot() {
-    return this.token === PathTokenEnum.ROOT;
-  }
-  isSeparator() {
-    return this.token === PathTokenEnum.SEP;
-  }
-  isPathElement() {
-    return this.token === PathTokenEnum.PATHELT;
-  }
-  isCurrent() {
-    return this.token === PathTokenEnum.CURRENT;
-  }
-  isParent() {
-    return this.token === PathTokenEnum.PARENT;
-  }
-  equals(ot) {
-    return ot.token === this.token && ot.value === this.value && ot.error === this.error;
-  }
-}
-export {
-  PathToken
-};