@gjsify/path 0.0.1 → 0.1.1

package/src/index.ts

@@ -0,0 +1,47 @@
+// Reference: Node.js lib/path.js
+// Reimplemented for GJS
+// Exports POSIX implementation by default (GJS runs on POSIX systems)
+
+import * as posix from './posix.js';
+import * as win32 from './win32.js';
+
+export type { ParsedPath, FormatInputPathObject } from './posix.js';
+
+// Re-export all POSIX functions as default path API
+export const {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  toNamespacedPath,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter,
+} = posix;
+
+// Export platform-specific implementations
+export { posix, win32 };
+
+// Default export is the posix module (matching Node.js behavior on POSIX systems)
+export default {
+  resolve: posix.resolve,
+  normalize: posix.normalize,
+  isAbsolute: posix.isAbsolute,
+  join: posix.join,
+  relative: posix.relative,
+  toNamespacedPath: posix.toNamespacedPath,
+  dirname: posix.dirname,
+  basename: posix.basename,
+  extname: posix.extname,
+  format: posix.format,
+  parse: posix.parse,
+  sep: posix.sep,
+  delimiter: posix.delimiter,
+  posix,
+  win32,
+};

package/src/posix.ts

@@ -0,0 +1,406 @@
+// SPDX-License-Identifier: MIT
+// Adapted from Deno (refs/deno/ext/node/polyfills/path/_posix.ts) and Node.js (refs/node/lib/path.js)
+// Copyright (c) 2018-2026 the Deno authors. MIT license.
+// Copyright (c) Node.js contributors. MIT license.
+// Modifications: TypeScript types, no primordials, GJS-compatible
+
+import { CHAR_DOT, CHAR_FORWARD_SLASH } from './constants.js';
+import {
+  assertPath,
+  isPosixPathSeparator,
+  normalizeString,
+  _format,
+} from './util.js';
+
+export interface ParsedPath {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+}
+
+export type FormatInputPathObject = Partial<ParsedPath>;
+
+export const sep = '/';
+export const delimiter = ':';
+
+function posixCwd(): string {
+  // In GJS, try GLib.get_current_dir() at runtime
+  if (typeof globalThis.process?.cwd === 'function') {
+    return globalThis.process.cwd();
+  }
+  // Fallback: try GLib
+  try {
+    const GLib = (globalThis as any).imports?.gi?.GLib;
+    if (GLib?.get_current_dir) {
+      return GLib.get_current_dir();
+    }
+  } catch {
+    // ignore
+  }
+  return '/';
+}
+
+export function resolve(...pathSegments: string[]): string {
+  let resolvedPath = '';
+  let resolvedAbsolute = false;
+
+  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path: string;
+    if (i >= 0) {
+      path = pathSegments[i];
+      assertPath(path);
+      if (path.length === 0) continue;
+    } else {
+      path = posixCwd();
+    }
+
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  }
+
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);
+
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0) {
+      return `/${resolvedPath}`;
+    }
+    return '/';
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  }
+  return '.';
+}
+
+export function normalize(path: string): string {
+  assertPath(path);
+
+  if (path.length === 0) return '.';
+
+  const isAbsolutePath = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
+
+  let normalized = normalizeString(path, !isAbsolutePath, '/', isPosixPathSeparator);
+
+  if (normalized.length === 0 && !isAbsolutePath) {
+    normalized = '.';
+  }
+  if (normalized.length > 0 && trailingSeparator) {
+    normalized += '/';
+  }
+
+  if (isAbsolutePath) {
+    return `/${normalized}`;
+  }
+  return normalized;
+}
+
+export function isAbsolute(path: string): boolean {
+  assertPath(path);
+  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+}
+
+export function join(...paths: string[]): string {
+  if (paths.length === 0) return '.';
+
+  let joined: string | undefined;
+  for (let i = 0; i < paths.length; ++i) {
+    const arg = paths[i];
+    assertPath(arg);
+    if (arg.length > 0) {
+      if (joined === undefined) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === undefined) return '.';
+  return normalize(joined);
+}
+
+export function relative(from: string, to: string): string {
+  assertPath(from);
+  assertPath(to);
+
+  if (from === to) return '';
+
+  from = resolve(from);
+  to = resolve(to);
+
+  if (from === to) return '';
+
+  // Find common prefix
+  let fromStart = 1;
+  const fromEnd = from.length;
+  const fromLen = fromEnd - fromStart;
+
+  let toStart = 1;
+  const toLen = to.length - toStart;
+
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+          return to.slice(toStart + i + 1);
+        } else if (i === 0) {
+          return to.slice(toStart + i);
+        }
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+          lastCommonSep = i;
+        } else if (i === 0) {
+          lastCommonSep = 0;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode) break;
+    if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
+  }
+
+  let out = '';
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (out.length === 0) {
+        out += '..';
+      } else {
+        out += '/..';
+      }
+    }
+  }
+
+  if (out.length > 0) {
+    return out + to.slice(toStart + lastCommonSep);
+  }
+
+  toStart += lastCommonSep;
+  if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) {
+    ++toStart;
+  }
+  return to.slice(toStart);
+}
+
+export function toNamespacedPath(path: string): string {
+  // On POSIX, this is a no-op
+  return path;
+}
+
+export function dirname(path: string): string {
+  assertPath(path);
+  if (path.length === 0) return '.';
+
+  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  let end = -1;
+  let matchedSlash = true;
+
+  for (let i = path.length - 1; i >= 1; --i) {
+    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      matchedSlash = false;
+    }
+  }
+
+  if (end === -1) return hasRoot ? '/' : '.';
+  if (hasRoot && end === 1) return '//';
+  return path.slice(0, end);
+}
+
+export function basename(path: string, ext?: string): string {
+  if (ext !== undefined) assertPath(ext);
+  assertPath(path);
+
+  let start = 0;
+  let end = -1;
+  let matchedSlash = true;
+
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path) return '';
+    let extIdx = ext.length - 1;
+    let firstNonSlashEnd = -1;
+    for (let i = path.length - 1; i >= 0; --i) {
+      const code = path.charCodeAt(i);
+      if (code === CHAR_FORWARD_SLASH) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1) {
+          matchedSlash = false;
+          firstNonSlashEnd = i + 1;
+        }
+        if (extIdx >= 0) {
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1) {
+              end = i;
+            }
+          } else {
+            extIdx = -1;
+            end = firstNonSlashEnd;
+          }
+        }
+      }
+    }
+
+    if (start === end) end = firstNonSlashEnd;
+    else if (end === -1) end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (let i = path.length - 1; i >= 0; --i) {
+      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+    }
+
+    if (end === -1) return '';
+    return path.slice(start, end);
+  }
+}
+
+export function extname(path: string): string {
+  assertPath(path);
+
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let preDotState = 0;
+
+  for (let i = path.length - 1; i >= 0; --i) {
+    const code = path.charCodeAt(i);
+    if (code === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      if (startDot === -1) {
+        startDot = i;
+      } else if (preDotState !== 1) {
+        preDotState = 1;
+      }
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    preDotState === 0 ||
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    return '';
+  }
+  return path.slice(startDot, end);
+}
+
+export function format(pathObject: FormatInputPathObject): string {
+  if (pathObject === null || typeof pathObject !== 'object') {
+    throw new TypeError(
+      'The "pathObject" argument must be of type Object. Received type ' + typeof pathObject
+    );
+  }
+  return _format('/', pathObject);
+}
+
+export function parse(path: string): ParsedPath {
+  assertPath(path);
+
+  const ret: ParsedPath = { root: '', dir: '', base: '', ext: '', name: '' };
+  if (path.length === 0) return ret;
+
+  const isAbsolutePath = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  let start: number;
+
+  if (isAbsolutePath) {
+    ret.root = '/';
+    start = 1;
+  } else {
+    start = 0;
+  }
+
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let i = path.length - 1;
+  let preDotState = 0;
+
+  for (; i >= start; --i) {
+    const code = path.charCodeAt(i);
+    if (code === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    preDotState === 0 ||
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    if (end !== -1) {
+      if (startPart === 0 && isAbsolutePath) {
+        ret.base = ret.name = path.slice(1, end);
+      } else {
+        ret.base = ret.name = path.slice(startPart, end);
+      }
+    }
+  } else {
+    if (startPart === 0 && isAbsolutePath) {
+      ret.name = path.slice(1, startDot);
+      ret.base = path.slice(1, end);
+    } else {
+      ret.name = path.slice(startPart, startDot);
+      ret.base = path.slice(startPart, end);
+    }
+    ret.ext = path.slice(startDot, end);
+  }
+
+  if (startPart > 0) {
+    ret.dir = path.slice(0, startPart - 1);
+  } else if (isAbsolutePath) {
+    ret.dir = '/';
+  }
+
+  return ret;
+}

package/src/test.mts

@@ -0,0 +1,6 @@
+
+import { run } from '@gjsify/unit';
+
+import pathTestSuite from './index.spec.js';
+
+run({ pathTestSuite });

package/src/util.ts

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: MIT
+// Adapted from Deno (refs/deno/ext/node/polyfills/path/) and Node.js (refs/node/lib/path.js)
+// Copyright (c) 2018-2026 the Deno authors. MIT license.
+// Copyright (c) Node.js contributors. MIT license.
+// Modifications: TypeScript types, no primordials
+
+import {
+  CHAR_DOT,
+  CHAR_FORWARD_SLASH,
+  CHAR_BACKWARD_SLASH,
+} from './constants.js';
+
+export function assertPath(path: unknown): asserts path is string {
+  if (typeof path !== 'string') {
+    throw new TypeError(
+      'The "path" argument must be of type string. Received type ' + typeof path
+    );
+  }
+}
+
+export function isPosixPathSeparator(code: number): boolean {
+  return code === CHAR_FORWARD_SLASH;
+}
+
+export function isPathSeparator(code: number): boolean {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+
+export function isWindowsDeviceRoot(code: number): boolean {
+  return (
+    (code >= 65 && code <= 90) ||  // A-Z
+    (code >= 97 && code <= 122)    // a-z
+  );
+}
+
+/**
+ * Resolves `.` and `..` segments in a path string.
+ */
+export function normalizeString(
+  path: string,
+  allowAboveRoot: boolean,
+  separator: string,
+  isPathSep: (code: number) => boolean
+): string {
+  let res = '';
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code: number;
+
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (isPathSep(code!)) {
+      break;
+    } else {
+      code = CHAR_FORWARD_SLASH;
+    }
+
+    if (isPathSep(code)) {
+      if (lastSlash === i - 1 || dots === 1) {
+        // NOOP — skip consecutive separators or single dot
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (
+          res.length < 2 ||
+          lastSegmentLength !== 2 ||
+          res.charCodeAt(res.length - 1) !== CHAR_DOT ||
+          res.charCodeAt(res.length - 2) !== CHAR_DOT
+        ) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf(separator);
+            if (lastSlashIndex === -1) {
+              res = '';
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length === 2 || res.length === 1) {
+            res = '';
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += `${separator}..`;
+          } else {
+            res = '..';
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += separator + path.slice(lastSlash + 1, i);
+        } else {
+          res = path.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === CHAR_DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+
+  return res;
+}
+
+/**
+ * Format a parsed path object into a path string.
+ */
+export function _format(sep: string, pathObject: Record<string, any>): string {
+  if (pathObject === null || typeof pathObject !== 'object') {
+    throw new TypeError(
+      'The "pathObject" argument must be of type Object. Received type ' + typeof pathObject
+    );
+  }
+
+  const dir = pathObject.dir || pathObject.root;
+  const base =
+    pathObject.base || (pathObject.name || '') + formatExt(pathObject.ext);
+
+  if (!dir) {
+    return base;
+  }
+
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+
+  return dir + sep + base;
+}
+
+function formatExt(ext?: string): string {
+  return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
+}