@gjsify/fs 0.1.15 → 0.2.0

package/src/glob.spec.ts

@@ -0,0 +1,201 @@
+// Ported from refs/bun/test/js/node/fs/glob.test.ts
+// Original: MIT, Oven & contributors.
+// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
+
+import { describe, it, expect } from '@gjsify/unit';
+import {
+  globSync,
+  glob,
+  promises,
+  mkdirSync,
+  writeFileSync,
+  mkdtempSync,
+  rmSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+function makeTmp(): string {
+  return mkdtempSync(join(tmpdir(), 'gjsify-glob-'));
+}
+
+export default async () => {
+  await describe('fs.globSync', async () => {
+    await it('matches *.ts files in flat directory', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'a.ts'), '');
+      writeFileSync(join(tmp, 'b.ts'), '');
+      writeFileSync(join(tmp, 'c.txt'), '');
+
+      const results = globSync('*.ts', { cwd: tmp });
+      expect(results.sort()).toStrictEqual(['a.ts', 'b.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('matches **/*.ts recursively', async () => {
+      const tmp = makeTmp();
+      mkdirSync(join(tmp, 'sub'));
+      writeFileSync(join(tmp, 'root.ts'), '');
+      writeFileSync(join(tmp, 'sub', 'nested.ts'), '');
+      writeFileSync(join(tmp, 'sub', 'other.txt'), '');
+
+      const results = globSync('**/*.ts', { cwd: tmp });
+      expect(results.sort()).toStrictEqual(['root.ts', 'sub/nested.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('matches files in a subdirectory pattern', async () => {
+      const tmp = makeTmp();
+      mkdirSync(join(tmp, 'src'));
+      writeFileSync(join(tmp, 'src', 'index.ts'), '');
+      writeFileSync(join(tmp, 'src', 'util.ts'), '');
+      writeFileSync(join(tmp, 'index.ts'), '');
+
+      const results = globSync('src/*.ts', { cwd: tmp });
+      expect(results.sort()).toStrictEqual(['src/index.ts', 'src/util.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('supports {a,b} alternation', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'a.ts'), '');
+      writeFileSync(join(tmp, 'b.ts'), '');
+      writeFileSync(join(tmp, 'c.ts'), '');
+
+      const results = globSync('*.{ts,js}', { cwd: tmp });
+      expect(results.sort()).toStrictEqual(['a.ts', 'b.ts', 'c.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('** matches all files and directories', async () => {
+      const tmp = makeTmp();
+      mkdirSync(join(tmp, 'sub'));
+      writeFileSync(join(tmp, 'a.ts'), '');
+      writeFileSync(join(tmp, 'sub', 'b.ts'), '');
+
+      const results = globSync('**', { cwd: tmp });
+      // Should include '.', 'a.ts', 'sub', 'sub/b.ts'
+      expect(results.includes('a.ts')).toBe(true);
+      expect(results.includes('sub/b.ts')).toBe(true);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('a/** matches the directory itself and its contents', async () => {
+      const tmp = makeTmp();
+      mkdirSync(join(tmp, 'sub'));
+      writeFileSync(join(tmp, 'sub', 'x.ts'), '');
+      writeFileSync(join(tmp, 'root.ts'), '');
+
+      const results = globSync('sub/**', { cwd: tmp });
+      expect(results.includes('sub')).toBe(true);
+      expect(results.includes('sub/x.ts')).toBe(true);
+      expect(results.includes('root.ts')).toBe(false);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('accepts array of patterns', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'a.ts'), '');
+      writeFileSync(join(tmp, 'b.js'), '');
+      writeFileSync(join(tmp, 'c.txt'), '');
+
+      const results = globSync(['*.ts', '*.js'], { cwd: tmp });
+      expect(results.sort()).toStrictEqual(['a.ts', 'b.js']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('exclude function filters out matching paths', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'a.ts'), '');
+      writeFileSync(join(tmp, 'b.ts'), '');
+
+      // Use **/*.ts so Node.js native also invokes the exclude function
+      // (flat patterns like *.ts skip directory traversal and exclude is not called)
+      const results = globSync('**/*.ts', {
+        cwd: tmp,
+        exclude: (p) => p === 'a.ts',
+      });
+      expect(results).toStrictEqual(['b.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('returns empty array when no files match', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'a.txt'), '');
+
+      const results = globSync('*.ts', { cwd: tmp });
+      expect(results).toStrictEqual([]);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('returns empty array for non-existent cwd', async () => {
+      const results = globSync('*.ts', { cwd: '/nonexistent-dir-gjsify-test' });
+      expect(results).toStrictEqual([]);
+    });
+  });
+
+  await describe('fs.glob (callback)', async () => {
+    await it('calls back with matched files', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'hello.ts'), '');
+      writeFileSync(join(tmp, 'world.ts'), '');
+
+      const results = await new Promise<string[]>((resolve, reject) => {
+        glob('*.ts', { cwd: tmp }, (err, matches) => {
+          if (err) return reject(err);
+          resolve(matches);
+        });
+      });
+
+      expect(results.sort()).toStrictEqual(['hello.ts', 'world.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('accepts callback as second argument (no options)', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'file.ts'), '');
+
+      const results = await new Promise<string[]>((resolve, reject) => {
+        (glob as any)('*.ts', (err: any, matches: string[]) => {
+          if (err) return reject(err);
+          resolve(matches);
+        });
+      });
+
+      // No cwd given — just verify it completes without error
+      expect(Array.isArray(results)).toBe(true);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+  });
+
+  await describe('fs.promises.glob', async () => {
+    await it('async iterates matched files', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'alpha.ts'), '');
+      writeFileSync(join(tmp, 'beta.ts'), '');
+
+      const results: string[] = [];
+      for await (const match of promises.glob('*.ts', { cwd: tmp })) {
+        results.push(match);
+      }
+
+      expect(results.sort()).toStrictEqual(['alpha.ts', 'beta.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('async iterates recursively with **/*.ts', async () => {
+      const tmp = makeTmp();
+      mkdirSync(join(tmp, 'lib'));
+      writeFileSync(join(tmp, 'index.ts'), '');
+      writeFileSync(join(tmp, 'lib', 'helper.ts'), '');
+
+      const results: string[] = [];
+      for await (const match of promises.glob('**/*.ts', { cwd: tmp })) {
+        results.push(match);
+      }
+
+      expect(results.sort()).toStrictEqual(['index.ts', 'lib/helper.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+  });
+};

package/src/glob.ts

@@ -0,0 +1,205 @@
+// Reference: Node.js lib/internal/fs/glob.js
+// Reimplemented for GJS using readdirSync (recursive) + pattern matching
+
+import { readdirSync } from './sync.js';
+import { normalizePath } from './utils.js';
+import type { PathLike } from 'node:fs';
+
+export interface GlobOptions {
+  cwd?: string | URL;
+  exclude?: string | string[] | ((path: string) => boolean);
+  withFileTypes?: boolean;
+}
+
+// ─── Pattern → RegExp conversion ─────────────────────────────────────────────
+
+/** Convert a single glob segment (no `/`) to a regex source string */
+function segmentToRegexSrc(seg: string): string {
+  // Handle extglob: !(pattern), *(pattern), +(pattern), ?(pattern), @(pattern)
+  const extglob = /^([!*+?@])\((.+)\)$/.exec(seg);
+  if (extglob) {
+    const [, type, inner] = extglob;
+    const parts = inner.split('|').map(p => segmentToRegexSrc(p));
+    const group = '(?:' + parts.join('|') + ')';
+    switch (type) {
+      case '!': return '(?!(?:' + parts.join('|') + '))[^/]*';
+      case '*': return group + '*';
+      case '+': return group + '+';
+      case '?': return group + '?';
+      case '@': return group;
+    }
+  }
+
+  let result = '';
+  let i = 0;
+  while (i < seg.length) {
+    const c = seg[i];
+    if (c === '*') { result += '[^/]*'; i++; continue; }
+    if (c === '?') { result += '[^/]'; i++; continue; }
+    if (c === '[') {
+      // Character class — pass through to regex
+      const end = seg.indexOf(']', i + 1);
+      if (end === -1) { result += '\\['; i++; continue; }
+      result += seg.slice(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    if (c === '{') {
+      // Alternation
+      const end = seg.indexOf('}', i + 1);
+      if (end === -1) { result += '\\{'; i++; continue; }
+      const alts = seg.slice(i + 1, end).split(',').map(a => segmentToRegexSrc(a.trim()));
+      result += '(?:' + alts.join('|') + ')';
+      i = end + 1;
+      continue;
+    }
+    // Escape regex special chars
+    if ('.+^$|()[]{}'.includes(c)) {
+      result += '\\' + c;
+    } else {
+      result += c;
+    }
+    i++;
+  }
+  return result;
+}
+
+/**
+ * Convert a glob pattern to a RegExp that matches relative POSIX paths.
+ */
+function globToRegex(pattern: string): RegExp {
+  // Normalize: collapse multiple slashes, remove leading './'
+  pattern = pattern.replace(/\/+/g, '/').replace(/^\.\//, '');
+
+  const segments = pattern.split('/');
+  const parts: string[] = [];
+
+  for (let si = 0; si < segments.length; si++) {
+    const seg = segments[si];
+    const isLast = si === segments.length - 1;
+
+    if (seg === '**') {
+      if (isLast) {
+        if (parts.length > 0 && parts[parts.length - 1] === '/') {
+          // Remove the trailing '/' so "a/" becomes optional: "a(?:/.*)?
+          parts.pop();
+          parts.push('(?:/.+)?');
+        } else {
+          // '**' at root level: match '.' or anything
+          parts.push('(?:.+)?');
+        }
+      } else {
+        // Not last: match zero or more path segments with trailing slash
+        parts.push('(?:[^/]+/)*');
+      }
+    } else {
+      parts.push(segmentToRegexSrc(seg));
+      if (!isLast) parts.push('/');
+    }
+  }
+
+  return new RegExp('^(?:' + parts.join('') + ')$');
+}
+
+// ─── Exclude logic ────────────────────────────────────────────────────────────
+
+function buildExcludePredicate(exclude: GlobOptions['exclude']): ((path: string) => boolean) | null {
+  if (!exclude) return null;
+  if (typeof exclude === 'function') return exclude;
+  const patterns = Array.isArray(exclude) ? exclude : [exclude];
+  const regexes = patterns.map(p => globToRegex(p));
+  return (path: string) => regexes.some(rx => rx.test(path));
+}
+
+// ─── Walk + match ─────────────────────────────────────────────────────────────
+
+function matchAll(pattern: string, cwd: string, exclude: GlobOptions['exclude']): string[] {
+  const regex = globToRegex(pattern);
+  const isExcluded = buildExcludePredicate(exclude);
+
+  // Get all entries recursively (files + directories)
+  let allEntries: string[];
+  try {
+    allEntries = readdirSync(cwd, { recursive: true }) as string[];
+  } catch {
+    return [];
+  }
+
+  // Include '.' itself for patterns like '**' that match the root
+  const candidates = ['.', ...allEntries];
+
+  const results: string[] = [];
+  for (const entry of candidates) {
+    // Normalize separators for matching
+    const normalized = entry.replace(/\\/g, '/');
+    if (!regex.test(normalized)) continue;
+    if (isExcluded && isExcluded(normalized)) continue;
+    results.push(entry);
+  }
+
+  return results;
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export function globSync(
+  pattern: string | string[],
+  options?: GlobOptions,
+): string[] {
+  const patterns = Array.isArray(pattern) ? pattern : [pattern];
+  const cwd = options?.cwd
+    ? normalizePath(options.cwd as PathLike)
+    : (globalThis as any).process?.cwd?.() ?? '/';
+  const exclude = options?.exclude;
+
+  const seen = new Set<string>();
+  const results: string[] = [];
+
+  for (const p of patterns) {
+    for (const match of matchAll(p, cwd, exclude)) {
+      if (!seen.has(match)) {
+        seen.add(match);
+        results.push(match);
+      }
+    }
+  }
+
+  return results;
+}
+
+export function glob(
+  pattern: string | string[],
+  options: GlobOptions | ((err: NodeJS.ErrnoException | null, matches: string[]) => void),
+  callback?: (err: NodeJS.ErrnoException | null, matches: string[]) => void,
+): void {
+  let opts: GlobOptions;
+  let cb: (err: NodeJS.ErrnoException | null, matches: string[]) => void;
+
+  if (typeof options === 'function') {
+    cb = options;
+    opts = {};
+  } else {
+    cb = callback!;
+    opts = options || {};
+  }
+
+  Promise.resolve().then(() => {
+    try {
+      const matches = globSync(pattern, opts);
+      cb(null, matches);
+    } catch (err: unknown) {
+      cb(err as NodeJS.ErrnoException, []);
+    }
+  });
+}
+
+// promises.glob returns an async iterator
+export async function* globAsync(
+  pattern: string | string[],
+  options?: GlobOptions,
+): AsyncIterableIterator<string> {
+  const matches = globSync(pattern, options);
+  for (const m of matches) {
+    yield m;
+  }
+}

package/src/index.ts

@@ -63,8 +63,30 @@ import {
   WriteStream
 } from './write-stream.js';
 import * as promises from './promises.js';
+import { cpSync, cp } from './cp.js';
+import { Dir, opendir, opendirSync } from './dir.js';
+import { glob, globSync } from './glob.js';
+import { StatWatcher, watchFile, unwatchFile } from './stat-watcher.js';
+import { statfsSync, statfs } from './statfs.js';
 import { Stats, BigIntStats } from './stats.js';
 import { Dirent } from './dirent.js';
+import {
+  utimesSync, utimes, lutimesSync, lutimes,
+  lchownSync, lchown, lchmodSync, lchmod,
+} from './utimes.js';
+import {
+  fstatSync, fstat,
+  ftruncateSync, ftruncate,
+  fdatasyncSync, fdatasync,
+  fsyncSync, fsync,
+  fchmodSync, fchmod,
+  fchownSync, fchown,
+  futimesSync, futimes,
+  closeSync, readSync, writeSync,
+  readvSync, readv,
+  writevSync, writev,
+  exists, openAsBlob,
+} from './fd-ops.js';
 
 // --- fs.constants ---
 export const constants = {
@@ -115,9 +137,11 @@ export const constants = {
 
 export {
   FSWatcher,
+  StatWatcher,
   Stats,
   BigIntStats,
   Dirent,
+  Dir,
   // Sync API
   existsSync,
   readdirSync,
@@ -142,7 +166,30 @@ export {
   truncateSync,
   chmodSync,
   chownSync,
+  cpSync,
+  opendirSync,
+  globSync,
+  glob,
   watch,
+  watchFile,
+  unwatchFile,
+  statfsSync,
+  statfs,
+  // utimes / lutimes / lchown / lchmod
+  utimesSync, utimes, lutimesSync, lutimes,
+  lchownSync, lchown, lchmodSync, lchmod,
+  // fd-based ops
+  fstatSync, fstat,
+  ftruncateSync, ftruncate,
+  fdatasyncSync, fdatasync,
+  fsyncSync, fsync,
+  fchmodSync, fchmod,
+  fchownSync, fchown,
+  futimesSync, futimes,
+  closeSync, readSync, writeSync,
+  readvSync, readv,
+  writevSync, writev,
+  exists, openAsBlob,
   // Streams
   createReadStream,
   ReadStream,
@@ -163,6 +210,7 @@ export {
   stat,
   rename,
   copyFile,
+  cp,
   access,
   appendFile,
   readlink,
@@ -175,13 +223,16 @@ export {
   writeFile,
   unlink,
   link,
+  opendir,
 };
 
 export default {
   FSWatcher,
+  StatWatcher,
   Stats,
   BigIntStats,
   Dirent,
+  Dir,
   constants,
   existsSync,
   readdirSync,
@@ -206,7 +257,28 @@ export default {
   truncateSync,
   chmodSync,
   chownSync,
+  cpSync,
+  opendirSync,
+  globSync,
+  glob,
   watch,
+  watchFile,
+  unwatchFile,
+  statfsSync,
+  statfs,
+  utimesSync, utimes, lutimesSync, lutimes,
+  lchownSync, lchown, lchmodSync, lchmod,
+  fstatSync, fstat,
+  ftruncateSync, ftruncate,
+  fdatasyncSync, fdatasync,
+  fsyncSync, fsync,
+  fchmodSync, fchmod,
+  fchownSync, fchown,
+  futimesSync, futimes,
+  closeSync, readSync, writeSync,
+  readvSync, readv,
+  writevSync, writev,
+  exists, openAsBlob,
   createReadStream,
   ReadStream,
   createWriteStream,
@@ -224,6 +296,7 @@ export default {
   stat,
   rename,
   copyFile,
+  cp,
   access,
   appendFile,
   readlink,
@@ -236,4 +309,5 @@ export default {
   writeFile,
   unlink,
   link,
+  opendir,
 };