@gjsify/module 0.4.0 → 0.4.3

package/package.json

@@ -1,44 +1,47 @@
 {
-  "name": "@gjsify/module",
-  "version": "0.4.0",
-  "description": "Node.js module module for Gjs",
-  "type": "module",
-  "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "default": "./lib/esm/index.js"
+    "name": "@gjsify/module",
+    "version": "0.4.3",
+    "description": "Node.js module module for Gjs",
+    "type": "module",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        }
+    },
+    "files": [
+        "lib"
+    ],
+    "scripts": {
+        "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+        "check": "tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "tsc",
+        "build:test": "gjsify run build:test:gjs && gjsify run build:test:node",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:node && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs",
+        "test:node": "node test.node.mjs"
+    },
+    "keywords": [
+        "gjs",
+        "node",
+        "module"
+    ],
+    "dependencies": {
+        "@girs/gio-2.0": "2.88.0-4.0.0-rc.15",
+        "@girs/gjs": "4.0.0-rc.15",
+        "@girs/glib-2.0": "2.88.0-4.0.0-rc.15",
+        "@gjsify/utils": "workspace:^"
+    },
+    "devDependencies": {
+        "@gjsify/cli": "workspace:^",
+        "@gjsify/unit": "workspace:^",
+        "@types/node": "^25.6.2",
+        "typescript": "^6.0.3"
     }
-  },
-  "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
-    "check": "tsc --noEmit",
-    "build": "yarn build:gjsify && yarn build:types",
-    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-    "build:types": "tsc",
-    "build:test": "yarn build:test:gjs && yarn build:test:node",
-    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
-    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
-    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
-    "test:gjs": "gjsify run test.gjs.mjs",
-    "test:node": "node test.node.mjs"
-  },
-  "keywords": [
-    "gjs",
-    "node",
-    "module"
-  ],
-  "dependencies": {
-    "@girs/gio-2.0": "2.88.0-4.0.0-rc.15",
-    "@girs/gjs": "4.0.0-rc.15",
-    "@girs/glib-2.0": "2.88.0-4.0.0-rc.15",
-    "@gjsify/utils": "^0.4.0"
-  },
-  "devDependencies": {
-    "@gjsify/cli": "^0.4.0",
-    "@gjsify/unit": "^0.4.0",
-    "@types/node": "^25.6.2",
-    "typescript": "^6.0.3"
-  }
-}
+}

package/src/index.spec.ts

@@ -1,386 +0,0 @@
-// Ported from refs/node-test/parallel/test-module-{isBuiltin,builtinModules,createRequire}.js
-// Original: MIT license, Node.js contributors
-
-import { describe, it, expect } from '@gjsify/unit';
-import { builtinModules, isBuiltin, createRequire } from 'node:module';
-
-export default async () => {
-  await describe('module.builtinModules', async () => {
-    await it('should be an array', async () => {
-      expect(Array.isArray(builtinModules)).toBe(true);
-    });
-
-    await it('should have more than 30 entries', async () => {
-      expect(builtinModules.length).toBeGreaterThan(30);
-    });
-
-    await it('should contain only strings', async () => {
-      for (const mod of builtinModules) {
-        expect(typeof mod).toBe('string');
-      }
-    });
-
-    await it('should not contain duplicates', async () => {
-      const unique = new Set(builtinModules);
-      expect(unique.size).toBe(builtinModules.length);
-    });
-
-    await it('should include fs', async () => {
-      expect(builtinModules).toContain('fs');
-    });
-
-    await it('should include path', async () => {
-      expect(builtinModules).toContain('path');
-    });
-
-    await it('should include os', async () => {
-      expect(builtinModules).toContain('os');
-    });
-
-    await it('should include crypto', async () => {
-      expect(builtinModules).toContain('crypto');
-    });
-
-    await it('should include http', async () => {
-      expect(builtinModules).toContain('http');
-    });
-
-    await it('should include net', async () => {
-      expect(builtinModules).toContain('net');
-    });
-
-    await it('should include stream', async () => {
-      expect(builtinModules).toContain('stream');
-    });
-
-    await it('should include events', async () => {
-      expect(builtinModules).toContain('events');
-    });
-
-    await it('should include buffer', async () => {
-      expect(builtinModules).toContain('buffer');
-    });
-
-    await it('should include util', async () => {
-      expect(builtinModules).toContain('util');
-    });
-
-    await it('should include dns', async () => {
-      expect(builtinModules).toContain('dns');
-    });
-
-    await it('should include https', async () => {
-      expect(builtinModules).toContain('https');
-    });
-
-    await it('should include tls', async () => {
-      expect(builtinModules).toContain('tls');
-    });
-
-    await it('should include dgram', async () => {
-      expect(builtinModules).toContain('dgram');
-    });
-
-    await it('should include assert', async () => {
-      expect(builtinModules).toContain('assert');
-    });
-
-    await it('should include querystring', async () => {
-      expect(builtinModules).toContain('querystring');
-    });
-
-    await it('should include url', async () => {
-      expect(builtinModules).toContain('url');
-    });
-
-    await it('should include string_decoder', async () => {
-      expect(builtinModules).toContain('string_decoder');
-    });
-
-    await it('should include timers', async () => {
-      expect(builtinModules).toContain('timers');
-    });
-
-    await it('should include zlib', async () => {
-      expect(builtinModules).toContain('zlib');
-    });
-
-    await it('should include child_process', async () => {
-      expect(builtinModules).toContain('child_process');
-    });
-
-    await it('should include cluster', async () => {
-      expect(builtinModules).toContain('cluster');
-    });
-
-    await it('should include console', async () => {
-      expect(builtinModules).toContain('console');
-    });
-
-    await it('should include domain', async () => {
-      expect(builtinModules).toContain('domain');
-    });
-
-    await it('should include http2', async () => {
-      expect(builtinModules).toContain('http2');
-    });
-
-    await it('should include module', async () => {
-      expect(builtinModules).toContain('module');
-    });
-
-    await it('should include perf_hooks', async () => {
-      expect(builtinModules).toContain('perf_hooks');
-    });
-
-    await it('should include process', async () => {
-      expect(builtinModules).toContain('process');
-    });
-
-    await it('should include readline', async () => {
-      expect(builtinModules).toContain('readline');
-    });
-
-    await it('should include tty', async () => {
-      expect(builtinModules).toContain('tty');
-    });
-
-    await it('should include v8', async () => {
-      expect(builtinModules).toContain('v8');
-    });
-
-    await it('should include vm', async () => {
-      expect(builtinModules).toContain('vm');
-    });
-
-    await it('should include worker_threads', async () => {
-      expect(builtinModules).toContain('worker_threads');
-    });
-
-    await it('should include bare names (without node: prefix)', async () => {
-      const bareModules = builtinModules.filter(m => !m.startsWith('node:'));
-      expect(bareModules.length).toBeGreaterThan(30);
-      expect(bareModules).toContain('fs');
-    });
-  });
-
-  await describe('module.isBuiltin', async () => {
-    await it('should be a function', async () => {
-      expect(typeof isBuiltin).toBe('function');
-    });
-
-    await it('should return true for fs', async () => {
-      expect(isBuiltin('fs')).toBe(true);
-    });
-
-    await it('should return true for path', async () => {
-      expect(isBuiltin('path')).toBe(true);
-    });
-
-    await it('should return true for os', async () => {
-      expect(isBuiltin('os')).toBe(true);
-    });
-
-    await it('should return true for crypto', async () => {
-      expect(isBuiltin('crypto')).toBe(true);
-    });
-
-    await it('should return true for http', async () => {
-      expect(isBuiltin('http')).toBe(true);
-    });
-
-    await it('should return true for node:fs', async () => {
-      expect(isBuiltin('node:fs')).toBe(true);
-    });
-
-    await it('should return true for node:path', async () => {
-      expect(isBuiltin('node:path')).toBe(true);
-    });
-
-    await it('should return true for node:os', async () => {
-      expect(isBuiltin('node:os')).toBe(true);
-    });
-
-    await it('should return true for node:crypto', async () => {
-      expect(isBuiltin('node:crypto')).toBe(true);
-    });
-
-    await it('should return true for node:events', async () => {
-      expect(isBuiltin('node:events')).toBe(true);
-    });
-
-    await it('should return true for node:stream', async () => {
-      expect(isBuiltin('node:stream')).toBe(true);
-    });
-
-    await it('should return true for node:buffer', async () => {
-      expect(isBuiltin('node:buffer')).toBe(true);
-    });
-
-    await it('should return true for node:util', async () => {
-      expect(isBuiltin('node:util')).toBe(true);
-    });
-
-    await it('should return false for npm packages', async () => {
-      expect(isBuiltin('@babel/core')).toBe(false);
-      expect(isBuiltin('lodash')).toBe(false);
-      expect(isBuiltin('express')).toBe(false);
-    });
-
-    await it('should return false for empty string', async () => {
-      expect(isBuiltin('')).toBe(false);
-    });
-
-    await it('should return false for nonexistent module', async () => {
-      expect(isBuiltin('nonexistent')).toBe(false);
-    });
-
-    await it('should return false for relative paths', async () => {
-      expect(isBuiltin('./fs')).toBe(false);
-      expect(isBuiltin('../path')).toBe(false);
-    });
-
-    await it('should return false for absolute paths', async () => {
-      expect(isBuiltin('/absolute/path')).toBe(false);
-    });
-
-    await it('should return true for subpath fs/promises', async () => {
-      expect(isBuiltin('fs/promises')).toBe(true);
-    });
-
-    await it('should return true for subpath dns/promises', async () => {
-      expect(isBuiltin('dns/promises')).toBe(true);
-    });
-
-    await it('should return true for subpath timers/promises', async () => {
-      expect(isBuiltin('timers/promises')).toBe(true);
-    });
-
-    await it('should return true for subpath node:fs/promises', async () => {
-      expect(isBuiltin('node:fs/promises')).toBe(true);
-    });
-
-    await it('should return false for scoped package with node name', async () => {
-      expect(isBuiltin('@types/node')).toBe(false);
-    });
-
-    await it('should return true for stream', async () => {
-      expect(isBuiltin('stream')).toBe(true);
-    });
-
-    await it('should return true for assert', async () => {
-      expect(isBuiltin('assert')).toBe(true);
-    });
-
-    await it('should return true for diagnostics_channel', async () => {
-      expect(isBuiltin('diagnostics_channel')).toBe(true);
-    });
-
-    await it('should return true for async_hooks', async () => {
-      expect(isBuiltin('async_hooks')).toBe(true);
-    });
-  });
-
-  await describe('module.createRequire', async () => {
-    await it('should be a function', async () => {
-      expect(typeof createRequire).toBe('function');
-    });
-
-    await it('should accept import.meta.url', async () => {
-      const req = createRequire(import.meta.url);
-      expect(typeof req).toBe('function');
-    });
-
-    await it('should throw for relative path', async () => {
-      let threw = false;
-      try {
-        createRequire('relative/path.js');
-      } catch {
-        threw = true;
-      }
-      expect(threw).toBe(true);
-    });
-
-    await it('returned require should have resolve', async () => {
-      const req = createRequire(import.meta.url);
-      expect(typeof req.resolve).toBe('function');
-    });
-
-    await it('returned require should have resolve.paths', async () => {
-      const req = createRequire(import.meta.url);
-      expect(typeof req.resolve.paths).toBe('function');
-    });
-
-    await it('returned require should have cache', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.cache).toBeDefined();
-      expect(typeof req.cache).toBe('object');
-    });
-
-    await it('returned require should have extensions', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.extensions).toBeDefined();
-      expect(typeof req.extensions).toBe('object');
-    });
-
-    await it('resolve.paths should return null for builtins', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.resolve.paths('fs')).toBeNull();
-    });
-
-    await it('resolve should return module name for fs', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.resolve('fs')).toBe('fs');
-    });
-
-    await it('resolve should return module name for path', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.resolve('path')).toBe('path');
-    });
-
-    await it('resolve should return module name for os', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.resolve('os')).toBe('os');
-    });
-
-    await it('resolve should return module name for events', async () => {
-      const req = createRequire(import.meta.url);
-      expect(req.resolve('events')).toBe('events');
-    });
-
-    await it('resolve should honor pkg.exports subpath maps (Phase C)', async () => {
-      // `@gjsify/rolldown-plugin-gjsify` exports `./shims/console-gjs` →
-      // `./lib/shims/console-gjs.js`. Without exports-map support this
-      // call fell back to the literal walk and returned a non-existent
-      // path; with the Phase-C resolver the spec-defined subpath wins.
-      const req = createRequire(import.meta.url);
-      const resolved = req.resolve('@gjsify/rolldown-plugin-gjsify/shims/console-gjs');
-      expect(typeof resolved).toBe('string');
-      expect(resolved.endsWith('/lib/shims/console-gjs.js')).toBe(true);
-    });
-
-    await it('resolve should honor pkg.exports root entry (.)', async () => {
-      // `@gjsify/rolldown-plugin-gjsify` root export is the object-form
-      // `{ "types": "./lib/index.d.ts", "default": "./lib/index.js" }`
-      // — exports-map resolution picks `default` for the runtime require.
-      const req = createRequire(import.meta.url);
-      const resolved = req.resolve('@gjsify/rolldown-plugin-gjsify');
-      expect(typeof resolved).toBe('string');
-      expect(resolved.endsWith('/lib/index.js')).toBe(true);
-    });
-  });
-
-  await describe('module exports', async () => {
-    await it('should export builtinModules', async () => {
-      expect(builtinModules).toBeDefined();
-    });
-
-    await it('should export isBuiltin', async () => {
-      expect(typeof isBuiltin).toBe('function');
-    });
-
-    await it('should export createRequire', async () => {
-      expect(typeof createRequire).toBe('function');
-    });
-  });
-};