@zenfs/core 2.5.1 → 2.5.2

package/dist/node/promises.js

@@ -898,25 +898,33 @@ export async function statfs(path, opts) {
 export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = opt || {};
-    // Escape special characters in pattern
-    const regexPatterns = pattern.map(globToRegex);
+    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
+    const patternBases = normalizedPatterns.map(p => {
+        const firstGlob = p.search(/[*?[\]{]/);
+        if (firstGlob === -1)
+            return p;
+        const lastSlash = p.lastIndexOf('/', firstGlob);
+        return lastSlash === -1 ? '' : p.slice(0, lastSlash);
+    });
+    const regexPatterns = normalizedPatterns.map(globToRegex);
     async function* recursiveList(dir) {
         const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
-            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
+            const fullPath = join(dir, withFileTypes ? entry.name : entry);
             if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
-            /**
-             * @todo is the pattern.source check correct?
-             */
-            if ((await stat(fullPath)).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
-                yield* recursiveList(fullPath);
+            const relativePath = fullPath.replace(/^\/+/g, '');
+            if ((await stat(fullPath)).isDirectory()) {
+                if (hasGlobStar || patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'))) {
+                    yield* recursiveList(fullPath);
+                }
             }
-            if (regexPatterns.some(pattern => pattern.test(fullPath.replace(/^\/+/g, '')))) {
-                yield withFileTypes ? entry : fullPath.replace(/^\/+/g, '');
+            if (regexPatterns.some(rx => rx.test(relativePath))) {
+                yield withFileTypes ? entry : relativePath;
             }
         }
     }
-    return recursiveList(cwd);
+    return recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
 }
 glob;

package/dist/node/sync.js

@@ -656,27 +656,35 @@ export function statfsSync(path, options) {
 export function globSync(pattern, options = {}) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = options;
-    // Escape special characters in pattern
-    const regexPatterns = pattern.map(globToRegex);
+    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
+    const patternBases = normalizedPatterns.map(p => {
+        const firstGlob = p.search(/[*?[\]{]/);
+        if (firstGlob === -1)
+            return p;
+        const lastSlash = p.lastIndexOf('/', firstGlob);
+        return lastSlash === -1 ? '' : p.slice(0, lastSlash);
+    });
+    const regexPatterns = normalizedPatterns.map(globToRegex);
     const results = [];
     function recursiveList(dir) {
         const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
-            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
+            const fullPath = join(dir, withFileTypes ? entry.name : entry);
             if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
-            /**
-             * @todo is the pattern.source check correct?
-             */
-            if (statSync(fullPath).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
-                recursiveList(fullPath);
+            const relativePath = fullPath.replace(/^\/+/g, '');
+            if (statSync(fullPath).isDirectory()) {
+                if (hasGlobStar || patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'))) {
+                    recursiveList(fullPath);
+                }
             }
-            if (regexPatterns.some(pattern => pattern.test(fullPath.replace(/^\/+/g, '')))) {
-                results.push(withFileTypes ? entry : fullPath.replace(/^\/+/g, ''));
+            if (regexPatterns.some(rx => rx.test(relativePath))) {
+                results.push(withFileTypes ? entry : relativePath);
             }
         }
     }
-    recursiveList(cwd);
+    recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
     return results;
 }
 globSync;

package/dist/utils.js

@@ -97,11 +97,16 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
  * @internal
  */
 export function globToRegex(pattern) {
+    const GLOBSTAR = '\0GS\0';
+    const STAR = '\0S\0';
     pattern = pattern
-        .replace(/([.?+^$(){}|[\]/])/g, '$1')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '.');
+        .replace(/\*\*/g, GLOBSTAR)
+        .replace(/\*/g, STAR)
+        .replace(/[.+^$(){}|[\]\\]/g, '\\$&')
+        .replace(/\?/g, '.')
+        .replaceAll('/' + GLOBSTAR + '/', '(?:/.*)?/')
+        .replaceAll(GLOBSTAR, '.*')
+        .replaceAll(STAR, '[^/]*');
     return new RegExp(`^${pattern}$`);
 }
 export async function waitOnline(worker) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.5.1",
+	"version": "2.5.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/tests/common/glob.test.ts

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+// Set up a directory structure for glob tests
+fs.mkdirSync('/glob');
+fs.mkdirSync('/glob/sub');
+fs.mkdirSync('/glob/sub/deep');
+fs.writeFileSync('/glob/a.txt', 'a');
+fs.writeFileSync('/glob/b.txt', 'b');
+fs.writeFileSync('/glob/c.js', 'c');
+fs.writeFileSync('/glob/sub/d.txt', 'd');
+fs.writeFileSync('/glob/sub/e.js', 'e');
+fs.writeFileSync('/glob/sub/deep/f.txt', 'f');
+
+suite('globSync', () => {
+	test('wildcard in root', () => {
+		const results = fs.globSync('glob/*');
+		assert(results.includes('glob/a.txt'), 'should include glob/a.txt');
+		assert(results.includes('glob/b.txt'), 'should include glob/b.txt');
+		assert(results.includes('glob/c.js'), 'should include glob/c.js');
+		assert(results.includes('glob/sub'), 'should include glob/sub');
+	});
+
+	test('wildcard with absolute path pattern', () => {
+		const results = fs.globSync('/glob/*');
+		assert(results.includes('glob/a.txt'), 'should include glob/a.txt');
+		assert(results.includes('glob/b.txt'), 'should include glob/b.txt');
+		assert(results.includes('glob/c.js'), 'should include glob/c.js');
+	});
+
+	test('wildcard with extension filter', () => {
+		const results = fs.globSync('/glob/*.txt');
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(!results.includes('glob/c.js'), 'should not include .js files');
+	});
+
+	test('nested path wildcard', () => {
+		const results = fs.globSync('/glob/sub/*');
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/e.js'));
+		assert(!results.includes('glob/a.txt'), 'should not include files from parent');
+	});
+
+	test('globstar (**)', () => {
+		const results = fs.globSync('/glob/**/*.txt');
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/deep/f.txt'));
+		assert(!results.includes('glob/c.js'), 'should not include .js files');
+	});
+
+	test('question mark wildcard', () => {
+		const results = fs.globSync('/glob/?.txt');
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(!results.includes('glob/c.js'));
+	});
+
+	test('multiple patterns', () => {
+		const results = fs.globSync(['/glob/*.txt', '/glob/*.js']);
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/c.js'));
+	});
+
+	test('no matches returns empty', () => {
+		const results = fs.globSync('/glob/*.xyz');
+		assert.equal(results.length, 0);
+	});
+
+	test('withFileTypes option', () => {
+		const results = fs.globSync('/glob/*.txt', { withFileTypes: true });
+		assert(results.length > 0, 'should have results');
+		assert(typeof results[0] === 'object' && 'name' in results[0], 'results should be Dirent objects');
+	});
+
+	test('exclude option with function', () => {
+		const results = fs.globSync('/glob/*', { exclude: path => typeof path === 'string' && path.endsWith('.js') });
+		assert(!results.includes('glob/c.js'), 'should exclude .js files');
+		assert(results.includes('glob/a.txt'), 'should still include .txt files');
+	});
+});
+
+await suite('promises.glob', () => {
+	test('wildcard in root', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(results.includes('glob/c.js'));
+		assert(results.includes('glob/sub'));
+	});
+
+	test('wildcard with absolute path pattern', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+	});
+
+	test('wildcard with extension filter', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*.txt'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(!results.includes('glob/c.js'));
+	});
+
+	test('nested path wildcard', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/sub/*'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/e.js'));
+		assert(!results.includes('glob/a.txt'));
+	});
+
+	test('globstar (**)', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/**/*.txt'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/deep/f.txt'));
+		assert(!results.includes('glob/c.js'));
+	});
+
+	test('multiple patterns', async () => {
+		const results = await Array.fromAsync(fs.promises.glob(['/glob/*.txt', '/glob/*.js']));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/c.js'));
+	});
+
+	test('no matches returns empty', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*.xyz'));
+		assert.equal(results.length, 0);
+	});
+});