@mangos/filepath 0.0.8 → 1.0.1

package/dist/absorbers/ddp.js

@@ -0,0 +1,46 @@
+import { TokenEnum } from "../constants.js";
+import { Token } from "../Token.js";
+import { tdpBodyAbsorber } from "./tdp.js";
+const regExpOrderedMapDDP = {
+  //  \\?\UNC\Server\Share\
+  //  \\.\UNC\Server\Share\
+  ddpwithUNC: /^(\/\/|\\\\)(.|\\?)(\/|\\)(unc)(\/|\\)([^/\\]+)(\/|\\)([^/\\]+)(\/|\\)?/i,
+  // example  \\.\Volume{b75e2c83-0000-0000-0000-602f00000000}\
+  // example  \\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\
+  ddpwithVolumeUUID: /^(\/\/|\\\\)(.|\\?)(\/|\\)(Volume{[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}})(\\|\/)?/i,
+  // example  \\?\C:\
+  // example  \\.\C:\
+  ddpwithTDP: /^(\/\/|\\\\)(.|\\?)(\/|\\)([a-z]:)(\/|\\)?/i
+};
+const createRootValueMap = {
+  ddpwithVolumeUUID(match) {
+    return `\\\\?\\${match[4]}`;
+  },
+  ddpwithUNC(match) {
+    return `\\\\?\\UNC\\${match[6]}\\${match[8]}`;
+  },
+  ddpwithTDP(match) {
+    return `\\\\?\\${match[4]}`;
+  }
+};
+function createRootToken(value, offset = 0) {
+  return new Token(TokenEnum.ROOT, value, offset, offset + value.length - 1);
+}
+function* ddpAbsorber(str = "", start = 0, end = str.length - 1) {
+  const pks = Object.keys(regExpOrderedMapDDP);
+  for (const pk of pks) {
+    const match = str.match(regExpOrderedMapDDP[pk]);
+    if (match === null) {
+      continue;
+    }
+    const rootValue = createRootValueMap[pk](match);
+    const record = createRootToken(rootValue, start);
+    yield record;
+    yield* tdpBodyAbsorber(str, record.end + 1, end);
+    break;
+  }
+}
+export {
+  ddpAbsorber,
+  regExpOrderedMapDDP
+};

package/dist/absorbers/posix.d.ts

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

package/dist/absorbers/posix.js

@@ -0,0 +1,33 @@
+import absorbSuccessiveValues from "../absorbSuccessiveValues.js";
+import { TokenEnum } from "../constants.js";
+import { Token } 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);
+    i = root.end + 1;
+  }
+  let toggle = 0;
+  while (i <= end) {
+    const coalescer = toggle === 0 ? (s) => s !== "/" : (s) => s === "/";
+    const result = absorbSuccessiveValues(str, coalescer, i, end);
+    if (result) {
+      const value = str.slice(i, result.end + 1);
+      let token = togglePathFragment[toggle % 2];
+      if (value === "..") {
+        token = TokenEnum.PARENT;
+      }
+      if (value === ".") {
+        token = TokenEnum.CURRENT;
+      }
+      yield new Token(token, value, result.start, result.end);
+      i = result.end + 1;
+    }
+    toggle = ++toggle % 2;
+  }
+}
+export {
+  posixAbsorber as default
+};

package/dist/absorbers/tdp.d.ts

@@ -0,0 +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>;

package/dist/absorbers/tdp.js

@@ -0,0 +1,132 @@
+import absorbSuccessiveValues from "../absorbSuccessiveValues.js";
+import { TokenEnum } from "../constants.js";
+import getCWD from "../getCWD.js";
+import getDrive from "../getDrive.js";
+import mapPlatformNames from "../platform.js";
+import { Token } from "../Token.js";
+import { togglePathFragment } from "../togglePathFragment.js";
+import validSep from "../validSep.js";
+import { regExpOrderedMapDDP, ddpAbsorber } from "./ddp.js";
+import uncAbsorber, { uncRegExp } from "./unc.js";
+const regexpLD = /(CON|PRN|AUX|NUL|COM[\\d]|LPT[\\d]|PRN)/i;
+const forbiddenRegExp = /[<>:"/|?*<\0}]/;
+function isInValidMSDirecotryName(str = "", start = 0, end = str.length - 1) {
+  return forbiddenRegExp.test(str.slice(start, end + 1));
+}
+function tdpRootNeedsCorrection(str) {
+  const match = str.match(/^[/\\]+/);
+  if (match === null) {
+    return;
+  }
+  if (Object.entries({
+    ...regExpOrderedMapDDP,
+    unc: uncRegExp
+  }).find(([_, regexp]) => str.match(regexp))) {
+    return;
+  }
+  return { start: 0, end: match[0].length - 1 };
+}
+function getCWDDOSRoot() {
+  const ddpTokens = Array.from(ddpAbsorber(getCWD()));
+  if (ddpTokens.length) {
+    return ddpTokens[0];
+  }
+  const uncTokens = Array.from(uncAbsorber(getCWD()));
+  if (uncTokens.length) {
+    return uncTokens[0];
+  }
+  const drive = getDrive(getCWD());
+  if (drive[0] >= "a" && drive[0] <= "z" && drive[1] === ":") {
+    return new Token(TokenEnum.ROOT, `${drive.join("")}`, 0, 1);
+  }
+  return void 0;
+}
+function tdpFragment(str, start, end) {
+  return absorbSuccessiveValues(str, (s) => !validSep(s), start, end);
+}
+function tdpSeperator(str, start, end) {
+  return absorbSuccessiveValues(str, (s) => validSep(s), start, end);
+}
+function hasLegacyDeviceName(str) {
+  const match = str.match(regexpLD);
+  if (Array.isArray(match)) {
+    return match[0];
+  }
+}
+function* tdpAbsorber(str = "") {
+  let i = 0;
+  let end = str.length - 1;
+  const result = tdpRootNeedsCorrection(str.slice(i, str.length));
+  if (result) {
+    if (mapPlatformNames() === "win32") {
+      const winRoot = getCWDDOSRoot();
+      if (winRoot) {
+        yield winRoot;
+        if (result.end >= str.length - 1) {
+          return;
+        }
+        str = `${winRoot.value}\\${str.slice(result.end + 1)}`;
+        end = end + winRoot.value.length - (result.end + 1) + 1;
+        i = winRoot.value.length;
+        yield* tdpBodyAbsorber(str, i, end);
+        return;
+      }
+    }
+    const value = str.slice(result.start, result.end + 1);
+    yield new Token(
+      TokenEnum.PATHELT,
+      value,
+      0,
+      result.end,
+      `path ${str} contains invalid ${value} as path element`
+    );
+    i = result.end + 1;
+  }
+  if (str.slice(i, str.length - 1).match(uncRegExp)) {
+    return;
+  }
+  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);
+    i = 2;
+  }
+  yield* tdpBodyAbsorber(str, i, str.length - 1);
+}
+function* tdpBodyAbsorber(str = "", start, end = str.length - 1) {
+  let toggle = 0;
+  let i = start;
+  while (i <= end) {
+    const result = toggle === 0 ? tdpFragment(str, i, end) : tdpSeperator(str, i, end);
+    if (result) {
+      const value = toggle === 0 ? str.slice(i, result.end + 1) : "\\";
+      let token = togglePathFragment[toggle];
+      const errors = [];
+      if (toggle === 0) {
+        switch (value) {
+          case "..":
+            token = TokenEnum.PARENT;
+            break;
+          case ".":
+            token = TokenEnum.CURRENT;
+            break;
+          default: {
+            const ldn = hasLegacyDeviceName(value);
+            if (ldn) {
+              errors.push(`contains forbidden DOS legacy device name: ${ldn}`);
+            }
+            if (isInValidMSDirecotryName(value)) {
+              errors.push(`name "${value}" contains invalid characters`);
+            }
+          }
+        }
+      }
+      yield errors?.length ? new Token(token, value, result.start, result.end, errors?.join("|")) : new Token(token, value, result.start, result.end);
+      i = result.end + 1;
+    }
+    toggle = ++toggle % 2;
+  }
+}
+export {
+  tdpAbsorber as default,
+  tdpBodyAbsorber
+};

package/dist/absorbers/unc.d.ts

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

package/dist/absorbers/unc.js

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

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const TokenEnum: {
+    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 declare const TokenValueEnum: TokenValueEnumType;

package/dist/constants.js

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

package/dist/getCWD.d.ts

@@ -0,0 +1 @@
+export default function getCWD(): string;

package/dist/getCWD.js

@@ -0,0 +1,12 @@
+function getCWD() {
+  if (globalThis?.process) {
+    return global.process.cwd();
+  }
+  if (globalThis?.location?.pathname) {
+    return globalThis.location.pathname;
+  }
+  return "/";
+}
+export {
+  getCWD as default
+};

package/dist/getDrive.d.ts

@@ -0,0 +1 @@
+export default function getDrive(str: string): [string, string];

package/dist/getDrive.js

@@ -0,0 +1,7 @@
+function getDrive(str) {
+  const [a, b] = str.slice(0, 2).toLowerCase().split("");
+  return [a, b];
+}
+export {
+  getDrive as default
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+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 };

package/dist/index.js

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

package/dist/parser.d.ts

@@ -0,0 +1,17 @@
+import { ParsedPath } from './ParsedPath.js';
+import { ParsedPathError } from './ParsedPathError.js';
+import { Token } 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[];
+    firstError?: number;
+};
+declare function resolve(fromStr?: string, ...toFragments: string[]): ParsedPath | ParsedPathError;
+declare function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPath | ParsedPathError;
+type InferPathOptions = {
+    [key in FileSystem]+?: boolean;
+};
+export { resolve, type resolvePathObject, firstPath, allPath };

package/dist/parser.js

@@ -0,0 +1,161 @@
+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 getCWD from "./getCWD.js";
+import { ParsedPath } from "./ParsedPath.js";
+import { ParsedPathError } from "./ParsedPathError.js";
+import mapPlatformNames from "./platform.js";
+import { Token } from "./Token.js";
+const absorberMapping = {
+  unc: uncAbsorber,
+  dos: tdpAbsorber,
+  devicePath: ddpAbsorber,
+  posix: posixAbsorber
+};
+const allNamespaces = ["devicePath", "unc", "dos", "posix"];
+function firstPath(path = "", options = {}) {
+  const iterator = inferPathType(path, options);
+  const step = iterator.next();
+  if (step.done) {
+    return void 0;
+  }
+  return step.value;
+}
+function allPath(path = "", options = {}) {
+  return Array.from(inferPathType(path, options));
+}
+function createPathProcessor(path) {
+  return (ns) => {
+    const _tokens = Array.from(absorberMapping[ns](path));
+    if (_tokens.length === 0) {
+      return;
+    }
+    const rc = { type: ns, path: _tokens };
+    const hasError = _tokens.some((t) => !!t.error);
+    if (hasError) {
+      return new ParsedPathError(rc);
+    }
+    return new ParsedPath(rc);
+  };
+}
+function getErrors(parsed) {
+  return parsed.path.reduce((errors, token) => {
+    if (!token.error) {
+      return errors;
+    }
+    errors.push(token.error);
+    return errors;
+  }, []).join("|");
+}
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function upp(path) {
+  let _last;
+  for (_last = last(path); _last.token === TokenEnum.SEP; _last = last(path)) {
+    path.pop();
+  }
+  if (_last !== path[0]) {
+    path.pop();
+  }
+}
+function add(_tokens, token) {
+  if (token.token === TokenEnum.SEP) {
+    return;
+  }
+  let _last = last(_tokens);
+  for (; _last.token === TokenEnum.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));
+}
+function firstPathFromCWD() {
+  return firstPath(getCWD());
+}
+function resolve(fromStr = getCWD(), ...toFragments) {
+  let firstPathFrom = firstPath(fromStr) ?? firstPathFromCWD();
+  if (firstPathFrom instanceof ParsedPathError) {
+    throw TypeError(`"from" path contains errors: ${getErrors(firstPathFrom)}`);
+  }
+  if (firstPathFrom.isRelative()) {
+    toFragments.unshift(fromStr);
+    firstPathFrom = firstPathFromCWD();
+  }
+  return resolvePathObject(firstPathFrom, ...toFragments);
+}
+function resolvePathObject(from, ...toFragments) {
+  const firstToStr = toFragments.shift();
+  if (firstToStr === void 0) {
+    return from;
+  }
+  const firstPathTo = firstPath(firstToStr);
+  if (firstPathTo === void 0) {
+    return from;
+  }
+  if (firstPathTo instanceof ParsedPathError) {
+    throw TypeError(`"to" path contains errors: ${getErrors(firstPathTo)}`);
+  }
+  if (!firstPathTo.isRelative()) {
+    if (toFragments.length === 0) {
+      return firstPathTo;
+    }
+    return resolvePathObject(firstPathTo, ...toFragments);
+  }
+  const working = structuredClone(from.path);
+  for (const token of firstPathTo.path) {
+    switch (token.token) {
+      case TokenEnum.SEP:
+      case TokenEnum.CURRENT:
+        break;
+      case TokenEnum.PARENT:
+        upp(working);
+        break;
+      case TokenEnum.PATHELT:
+        add(working, token);
+        break;
+    }
+  }
+  const rc = new ParsedPath({ ...from, path: working });
+  if (toFragments.length === 0) {
+    return rc;
+  }
+  return resolvePathObject(rc, ...toFragments);
+}
+function getSeperator() {
+  if (mapPlatformNames() === "win32") {
+    return "\\";
+  }
+  return "/";
+}
+function defaultOptions(options = {}) {
+  if (allNamespaces.every((fs) => !(fs in options))) {
+    const isWindows = mapPlatformNames() === "win32";
+    return Object.assign(/* @__PURE__ */ Object.create(null), {
+      unc: isWindows,
+      dos: isWindows,
+      devicePath: isWindows,
+      posix: !isWindows
+    });
+  }
+  return options;
+}
+function* inferPathType(path, options = {}) {
+  const finalOptions = defaultOptions(options);
+  const processor = createPathProcessor(path);
+  const filtered = allNamespaces.filter((f) => finalOptions[f]);
+  for (const ns of filtered) {
+    const result = processor(ns);
+    if (result) {
+      yield result;
+    }
+  }
+  return;
+}
+export {
+  allPath,
+  firstPath,
+  resolve
+};

package/dist/platform.d.ts

@@ -0,0 +1 @@
+export default function mapPlatformNames(): NodeJS.Platform | undefined;

package/dist/platform.js

@@ -0,0 +1,19 @@
+function getPlatform() {
+  if ("userAgentData" in navigator) {
+    return navigator.userAgentData.platform.toLowerCase();
+  }
+  if ("platform" in navigator) {
+    return navigator.platform.toLowerCase();
+  }
+  return process?.platform;
+}
+function mapPlatformNames() {
+  const platform = getPlatform() ?? "linux";
+  if (platform.includes("win")) {
+    return "win32";
+  }
+  return "linux";
+}
+export {
+  mapPlatformNames as default
+};

package/dist/togglePathFragment.d.ts

@@ -0,0 +1 @@
+export declare const togglePathFragment: readonly ["\u0006", "\u0001"];

package/dist/togglePathFragment.js

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

package/dist/types/TokenValueType.d.ts

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

package/dist/validSep.d.ts

@@ -0,0 +1 @@
+export default function validSep(s: string | undefined): s is "/" | "\\";

package/dist/validSep.js

@@ -0,0 +1,6 @@
+function validSep(s) {
+  return s === "\\" || s === "/";
+}
+export {
+  validSep as default
+};

package/package.json

@@ -1,49 +1,61 @@
-{
-  "name": "@mangos/filepath",
-  "version": "0.0.8",
-  "description": "filepath parses UNC (long and short and cmd aliases) local filesystem path, and unix paths, checks for invalid path characters",
-  "keywords": [
-    "filepath",
-    "unc",
-    "posix pathname",
-    "universal naming convention",
-    "local file system",
-    "lfs",
-    "device path"
-  ],
-  "homepage": "https://github.com/R-js/mangos/blob/master/packages/filepath/README.md",
-  "bugs": {
-    "url": "https://github.com/R-js/mangos.git",
-    "email": "info@mail.jacob-bogers.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/R-js/mangos.git",
-    "directory": "packages/filepath"
-  },
-  "license": "MIT",
-  "author": "jacob.bogers <jkfbogers@gmail.com>",
-  "main": "index.js",
-  "scripts": {
-    "coverage": "nyc mocha",
-    "test": "mocha",
-    "lint": "eslint lib/**/*js",
-    "lint:other": "eslint test/**/*.js"
-  },
-  "nyc": {
-    "instrument": true,
-    "reporter": [
-      "html",
-      "text"
-    ]
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "chai": "4.2.0",
-    "chai-as-promised": "7.1.1",
-    "cross-env": "7.0.2",
-    "eslint": "6.8.0",
-    "mocha": "6.2.2",
-    "nyc": "14.1.1"
-  }
-}
+{
+	"name": "@mangos/filepath",
+	"version": "1.0.1",
+	"author": "jacob bogers <jkfbogers@gmail.com>",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/R-js/mangos.git",
+		"directory": "packages/filepath"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"types": "./dist/index.d.ts",
+	"main": "./dist/index.js",
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.8",
+		"@types/node": "^25.0.0",
+		"@vitest/coverage-v8": "^4.0.15",
+		"typescript": "^5.9.3",
+		"vite": "^7.2.7",
+		"vitest": "^4.0.15"
+	},
+	"bugs": {
+		"url": "https://github.com/R-js/mangos.git",
+		"email": "jkfbogers@gmail.com"
+	},
+	"description": "filepath parses UNC (long and short and cmd aliases) local filesystem path, and unix paths, checks for invalid path characters",
+	"engines": {
+		"node": ">=v20.8.0"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"package.json"
+	],
+	"homepage": "https://github.com/R-js/mangos/blob/master/packages/filepath/README.md",
+	"keywords": [
+		"file",
+		"path",
+		"unc",
+		"dos",
+		"linux",
+		"device path",
+		"universal naming convention",
+		"file system",
+		"lfs"
+	],
+	"license": "MIT",
+	"scripts": {
+		"prebuild": "npm run lint",
+		"build": "vite build && tsc",
+		"prepublishOnly": "npm run build",
+		"lint": "biome check",
+		"test": "vitest run --coverage"
+	},
+	"sideEffects": false,
+	"type": "module"
+}