pkgprn 0.4.1 → 0.5.0

package/index.d.ts.map

@@ -6,11 +6,11 @@
     "Logger"
   ],
   "sources": [
-    "prune.js"
+    "src/prune.js"
   ],
   "sourcesContent": [
     null
   ],
-  "mappings": ";;;;iBAsEsBA,QAAQA;aAhCUC,MAAMA",
+  "mappings": ";;;;iBAuEsBA,QAAQA;aAhCUC,MAAMA",
   "ignoreList": []
 }

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "pkgprn",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "license": "MIT",
   "author": "Konstantin Shutkin",
-  "bin": "./index.js",
+  "bin": "./src/index.js",
   "type": "module",
   "types": "./index.d.ts",
   "exports": {
     ".": {
       "types": "./index.d.ts",
-      "default": "./prune.js"
+      "default": "./src/prune.js"
     },
     "./package.json": "./package.json"
   },
@@ -29,11 +29,10 @@
     "type": "git",
     "url": "git+https://github.com/kshutkin/package-prune.git"
   },
-  "main": "prune.js",
+  "main": "src/prune.js",
   "dependencies": {
     "@jridgewell/sourcemap-codec": "^1.5.5",
     "@niceties/logger": "^1.1.13",
-    "cleye": "2.2.1",
-    "jsonata": "^2.1.0"
+    "cleye": "2.2.1"
   }
 }

package/src/extract-references.js

@@ -0,0 +1,81 @@
+/**
+ * Extracts all file path references from a package.json object.
+ *
+ * Replaces the jsonata expression:
+ *   [bin, bin.*, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*, directories.bin]
+ *
+ * @param {Record<string, unknown>} pkg
+ * @returns {unknown[]}
+ */
+export function extractReferences(pkg) {
+    /** @type {unknown[]} */
+    const result = [];
+
+    // bin — included as-is (string or object; non-strings are skipped by consuming code)
+    if (pkg.bin !== undefined && pkg.bin !== null) {
+        result.push(pkg.bin);
+    }
+
+    // bin.* — all values when bin is an object
+    if (typeof pkg.bin === 'object' && pkg.bin !== null && !Array.isArray(pkg.bin)) {
+        for (const value of Object.values(pkg.bin)) {
+            result.push(value);
+        }
+    }
+
+    // simple top-level fields: main, module, unpkg, umd, types, typings
+    const topLevelFields = ['main', 'module', 'unpkg', 'umd', 'types', 'typings'];
+    for (const field of topLevelFields) {
+        if (pkg[field] !== undefined && pkg[field] !== null) {
+            result.push(pkg[field]);
+        }
+    }
+
+    // exports[].*.* — navigate exactly 2 levels deep into the exports object.
+    // Level 1: values of the exports object (e.g. exports["."], exports["./second"])
+    // Level 2: values of each level-1 value (if it's an object)
+    // String values at level 1 are skipped (jsonata wildcard on string yields nothing).
+    // Array values at level 2 are flattened.
+    if (typeof pkg.exports === 'object' && pkg.exports !== null && !Array.isArray(pkg.exports)) {
+        for (const level1 of Object.values(pkg.exports)) {
+            if (typeof level1 === 'object' && level1 !== null && !Array.isArray(level1)) {
+                for (const level2 of Object.values(/** @type {Record<string, unknown>} */ (level1))) {
+                    if (Array.isArray(level2)) {
+                        for (const item of level2) {
+                            result.push(item);
+                        }
+                    } else {
+                        result.push(level2);
+                    }
+                }
+            }
+        }
+    }
+
+    // typesVersions.*.* — 2 levels of wildcard, arrays are flattened
+    if (typeof pkg.typesVersions === 'object' && pkg.typesVersions !== null && !Array.isArray(pkg.typesVersions)) {
+        for (const level1 of Object.values(pkg.typesVersions)) {
+            if (typeof level1 === 'object' && level1 !== null && !Array.isArray(level1)) {
+                for (const level2 of Object.values(/** @type {Record<string, unknown>} */ (level1))) {
+                    if (Array.isArray(level2)) {
+                        for (const item of level2) {
+                            result.push(item);
+                        }
+                    } else {
+                        result.push(level2);
+                    }
+                }
+            }
+        }
+    }
+
+    // directories.bin
+    if (typeof pkg.directories === 'object' && pkg.directories !== null) {
+        const dirs = /** @type {Record<string, unknown>} */ (pkg.directories);
+        if (dirs.bin !== undefined && dirs.bin !== null) {
+            result.push(dirs.bin);
+        }
+    }
+
+    return result;
+}

package/{prune.js → src/prune.js}

@@ -1,6 +1,7 @@
 import { access, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
+import { extractReferences } from './extract-references.js';
 import { adjustSourcemapLineMappings, isStrippableFile, parseCommentTypes, stripCommentsWithLineMap } from './strip-comments.js';
 
 /**
@@ -270,12 +271,9 @@ export async function prunePkg(pkg, options, logger) {
  * @param {Logger} logger
  */
 async function flatten(pkg, flatten, logger) {
-    const { default: jsonata } = await import('jsonata');
-
     // find out where is the dist folder
 
-    const expression = jsonata('[bin, bin.*, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*, directories.bin]');
-    const allReferences = await expression.evaluate(pkg);
+    const allReferences = extractReferences(pkg);
 
     /** @type {string[]} */
     let distDirs;