slim-package-json 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # Slim Package Json
 
-A cli tool for creating generating a package.json for containers that only includes the dependencies that were actually used
+A cli tool for creating generating a package.json for docker containers (or other environments) that only includes the dependencies that were actually used
 
 ## Installation
 
@@ -19,12 +19,14 @@ npm i slim-package-json
 slim-package-json --help
 
 # basic usage
+# specify the package json w/ the dependencies and the directory
+# where the built/bundled files are
 slim-package-json --package-json ./package.json --dir ./path/to/output/dir
-slim-package-json -P ./package.json -D ./path/to/output/dir
+slim-package-json -P ./package.json -D ./path/to/build/dir
 
 # inherit properties from a child package.json
-slim-package-json --package-json ./package.json --child-package-json ./apps/foo/package.json --dir ./apps/foo/dist
-slim-package-json -P ./package.json -C ./apps/foo/package.json -D ./apps/foo/dist
+slim-package-json --package-json ./package.json --extend-from ./apps/foo/package.json --dir ./apps/foo/dist
+slim-package-json -P ./package.json -E ./apps/foo/package.json -D ./apps/foo/dist
 ```
 
 ## TS Usage

package/dist/cli.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+const citty = require('citty');
+const index = require('./index.cjs');
+require('fs/promises');
+require('globby');
+require('path');
+
+const slimPackageJson = citty.defineCommand({
+  args: {
+    dir: {
+      type: "string",
+      alias: "D",
+      required: true,
+      description: "The directory where the built js/ts files are"
+    },
+    packageJson: {
+      type: "string",
+      alias: "P",
+      required: true,
+      description: "Location of your package.json that contains all the potential dependencies. Usually this is at the monorepo root."
+    },
+    extendFrom: {
+      type: "string",
+      alias: "E",
+      description: "A package.json that you want to inherit properties from"
+    }
+  },
+  async run({ args }) {
+    return index.generateSlimPackageJson(args);
+  }
+});
+void citty.runMain(slimPackageJson);

package/dist/cli.d.cts

@@ -0,0 +1 @@
+

package/dist/cli.d.mts

@@ -0,0 +1 @@
+

package/dist/cli.d.ts

@@ -0,0 +1 @@
+

package/dist/cli.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { generateSlimPackageJson } from './index.mjs';
+import 'fs/promises';
+import 'globby';
+import 'path';
+
+const slimPackageJson = defineCommand({
+  args: {
+    dir: {
+      type: "string",
+      alias: "D",
+      required: true,
+      description: "The directory where the built js/ts files are"
+    },
+    packageJson: {
+      type: "string",
+      alias: "P",
+      required: true,
+      description: "Location of your package.json that contains all the potential dependencies. Usually this is at the monorepo root."
+    },
+    extendFrom: {
+      type: "string",
+      alias: "E",
+      description: "A package.json that you want to inherit properties from"
+    }
+  },
+  async run({ args }) {
+    return generateSlimPackageJson(args);
+  }
+});
+void runMain(slimPackageJson);

package/dist/index.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const promises = require('fs/promises');
+const globby = require('globby');
+const path = require('path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+async function generateSlimPackageJson(args) {
+  console.info(`Loading file(s)`);
+  const workspacePackageJson = JSON.parse(
+    await promises.readFile(path__default.resolve(args.packageJson), {
+      encoding: "utf8"
+    })
+  );
+  const projectPackageJson = args.extendFrom ? JSON.parse(
+    await promises.readFile(path__default.resolve(args.extendFrom), {
+      encoding: "utf8"
+    })
+  ) : {};
+  const files = await globby.globby(
+    [
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.mjs",
+      "**/*.mts",
+      "**/*.cjs",
+      "**/*.cts"
+    ],
+    { cwd: path__default.resolve(args.dir) }
+  );
+  console.info(`Found ${files.length} file(s)`);
+  console.info(`Detecting used dependencies`);
+  const tasks = files.map(async (file) => {
+    const fileContent = await promises.readFile(path__default.resolve(args.dir, file), {
+      encoding: "utf8"
+    });
+    addUsedDependencies(
+      fileContent,
+      workspacePackageJson,
+      projectPackageJson
+    );
+  });
+  await Promise.all(tasks);
+  console.info(
+    `Detected ${Object.keys(projectPackageJson.dependencies ?? {}).length} used dependencies`
+  );
+  const outputFile = path__default.resolve(args.dir, "package.json");
+  await promises.writeFile(outputFile, JSON.stringify(projectPackageJson), {
+    encoding: "utf8"
+  });
+  console.info(`Successfully wrote package.json to ${outputFile}`);
+}
+function addUsedDependencies(fileContent, rootPackageJson, childPackageJson) {
+  for (const [key, val] of Object.entries(
+    rootPackageJson.dependencies ?? {}
+  )) {
+    if (fileContent.includes(`from '${key}`) || fileContent.includes(`from "${key}`) || fileContent.includes(`require('${key}`) || fileContent.includes(`require("${key}`)) {
+      if (!childPackageJson.dependencies) {
+        childPackageJson.dependencies = {};
+      }
+      childPackageJson.dependencies[key] = val;
+    }
+  }
+  for (const [key, val] of Object.entries(
+    rootPackageJson.devDependencies ?? {}
+  )) {
+    if (fileContent.includes(`from '${key}`) || fileContent.includes(`from "${key}`) || fileContent.includes(`require('${key}`) || fileContent.includes(`require("${key})`)) {
+      if (!childPackageJson.dependencies) {
+        childPackageJson.dependencies = {};
+      }
+      childPackageJson.dependencies[key] = val;
+    }
+  }
+}
+
+exports.addUsedDependencies = addUsedDependencies;
+exports.generateSlimPackageJson = generateSlimPackageJson;

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+type PackageJson = {
+    [key: string]: unknown;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+};
+type GeneratePackageJsonArgs = {
+    /**
+     * The package json containing all the potential dependencies
+     */
+    packageJson: string;
+    /**
+     * Path to a package.json that you want to inherit properties from.
+     *
+     * You might use this in a monorepo where all the dependencies are listed at the root but
+     * you have properties specific to one package in that package's directory that you want
+     * to preserve (such as engines, type, name, version, etc)
+     */
+    extendFrom?: string;
+    /**
+     * directory to check for used dependencies
+     */
+    dir: string;
+};
+declare function generateSlimPackageJson(args: GeneratePackageJsonArgs): Promise<void>;
+declare function addUsedDependencies(fileContent: string, rootPackageJson: PackageJson, childPackageJson: PackageJson): void;
+
+export { addUsedDependencies, generateSlimPackageJson };
+export type { GeneratePackageJsonArgs, PackageJson };

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+type PackageJson = {
+    [key: string]: unknown;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+};
+type GeneratePackageJsonArgs = {
+    /**
+     * The package json containing all the potential dependencies
+     */
+    packageJson: string;
+    /**
+     * Path to a package.json that you want to inherit properties from.
+     *
+     * You might use this in a monorepo where all the dependencies are listed at the root but
+     * you have properties specific to one package in that package's directory that you want
+     * to preserve (such as engines, type, name, version, etc)
+     */
+    extendFrom?: string;
+    /**
+     * directory to check for used dependencies
+     */
+    dir: string;
+};
+declare function generateSlimPackageJson(args: GeneratePackageJsonArgs): Promise<void>;
+declare function addUsedDependencies(fileContent: string, rootPackageJson: PackageJson, childPackageJson: PackageJson): void;
+
+export { addUsedDependencies, generateSlimPackageJson };
+export type { GeneratePackageJsonArgs, PackageJson };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+type PackageJson = {
+    [key: string]: unknown;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+};
+type GeneratePackageJsonArgs = {
+    /**
+     * The package json containing all the potential dependencies
+     */
+    packageJson: string;
+    /**
+     * Path to a package.json that you want to inherit properties from.
+     *
+     * You might use this in a monorepo where all the dependencies are listed at the root but
+     * you have properties specific to one package in that package's directory that you want
+     * to preserve (such as engines, type, name, version, etc)
+     */
+    extendFrom?: string;
+    /**
+     * directory to check for used dependencies
+     */
+    dir: string;
+};
+declare function generateSlimPackageJson(args: GeneratePackageJsonArgs): Promise<void>;
+declare function addUsedDependencies(fileContent: string, rootPackageJson: PackageJson, childPackageJson: PackageJson): void;
+
+export { addUsedDependencies, generateSlimPackageJson };
+export type { GeneratePackageJsonArgs, PackageJson };

package/dist/index.mjs

@@ -0,0 +1,75 @@
+import { readFile, writeFile } from 'fs/promises';
+import { globby } from 'globby';
+import path from 'path';
+
+async function generateSlimPackageJson(args) {
+  console.info(`Loading file(s)`);
+  const workspacePackageJson = JSON.parse(
+    await readFile(path.resolve(args.packageJson), {
+      encoding: "utf8"
+    })
+  );
+  const projectPackageJson = args.extendFrom ? JSON.parse(
+    await readFile(path.resolve(args.extendFrom), {
+      encoding: "utf8"
+    })
+  ) : {};
+  const files = await globby(
+    [
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.mjs",
+      "**/*.mts",
+      "**/*.cjs",
+      "**/*.cts"
+    ],
+    { cwd: path.resolve(args.dir) }
+  );
+  console.info(`Found ${files.length} file(s)`);
+  console.info(`Detecting used dependencies`);
+  const tasks = files.map(async (file) => {
+    const fileContent = await readFile(path.resolve(args.dir, file), {
+      encoding: "utf8"
+    });
+    addUsedDependencies(
+      fileContent,
+      workspacePackageJson,
+      projectPackageJson
+    );
+  });
+  await Promise.all(tasks);
+  console.info(
+    `Detected ${Object.keys(projectPackageJson.dependencies ?? {}).length} used dependencies`
+  );
+  const outputFile = path.resolve(args.dir, "package.json");
+  await writeFile(outputFile, JSON.stringify(projectPackageJson), {
+    encoding: "utf8"
+  });
+  console.info(`Successfully wrote package.json to ${outputFile}`);
+}
+function addUsedDependencies(fileContent, rootPackageJson, childPackageJson) {
+  for (const [key, val] of Object.entries(
+    rootPackageJson.dependencies ?? {}
+  )) {
+    if (fileContent.includes(`from '${key}`) || fileContent.includes(`from "${key}`) || fileContent.includes(`require('${key}`) || fileContent.includes(`require("${key}`)) {
+      if (!childPackageJson.dependencies) {
+        childPackageJson.dependencies = {};
+      }
+      childPackageJson.dependencies[key] = val;
+    }
+  }
+  for (const [key, val] of Object.entries(
+    rootPackageJson.devDependencies ?? {}
+  )) {
+    if (fileContent.includes(`from '${key}`) || fileContent.includes(`from "${key}`) || fileContent.includes(`require('${key}`) || fileContent.includes(`require("${key})`)) {
+      if (!childPackageJson.dependencies) {
+        childPackageJson.dependencies = {};
+      }
+      childPackageJson.dependencies[key] = val;
+    }
+  }
+}
+
+export { addUsedDependencies, generateSlimPackageJson };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "slim-package-json",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A cli tool for creating generating a package.json for containers that only includes the dependencies that were actually used",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "type": "module",
+  "bin": {
+    "slim-package-json": "./dist/cli.mjs"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
@@ -22,7 +25,8 @@
   "devDependencies": {
     "@types/node": "^25.6.0",
     "prettier": "^3.8.2",
-    "unbuild": "^3.6.1"
+    "unbuild": "^3.6.1",
+    "vitest": "^4.1.4"
   },
   "scripts": {
     "build": "unbuild"

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/src/cli.ts

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 import { generateSlimPackageJson } from '.';
 
@@ -16,11 +17,11 @@ const slimPackageJson = defineCommand({
             description:
                 'Location of your package.json that contains all the potential dependencies. Usually this is at the monorepo root.',
         },
-        childPackageJson: {
+        extendFrom: {
             type: 'string',
-            alias: 'C',
+            alias: 'E',
             description:
-                'Location of the package.json for the child project within the monorepo. If specified the generated package json will inherit all the properties from this package json.',
+                'A package.json that you want to inherit properties from',
         },
     },
     async run({ args }) {

package/src/index.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from 'vitest';
+import { addUsedDependencies, PackageJson } from '.';
+
+describe('addUsedDependencies', () => {
+    test('esm imports', () => {
+        const filecontents = [
+            `import {foo} from 'foo';`,
+            `import { bar } from "bar";`,
+        ];
+        const packageJson: PackageJson = {
+            dependencies: {
+                foo: '1.0.0',
+                bar: '1.1.1',
+                baz: '2.68.0-beta2',
+            },
+        };
+        const projectPackageJson: PackageJson = {};
+        for (const content of filecontents) {
+            addUsedDependencies(content, packageJson, projectPackageJson);
+        }
+        expect(projectPackageJson).toStrictEqual({
+            dependencies: { foo: '1.0.0', bar: '1.1.1' },
+        });
+    });
+    test('cjs require()', () => {
+        const filecontents = [
+            `const foo = require('foo');`,
+            `const bar = require("bar");`,
+        ];
+        const packageJson: PackageJson = {
+            dependencies: {
+                foo: '1.0.0',
+                bar: '1.1.1',
+                baz: '2.68.0-beta2',
+            },
+        };
+        const projectPackageJson: PackageJson = {};
+        for (const content of filecontents) {
+            addUsedDependencies(content, packageJson, projectPackageJson);
+        }
+        expect(projectPackageJson).toStrictEqual({
+            dependencies: { foo: '1.0.0', bar: '1.1.1' },
+        });
+    });
+});

package/src/index.ts

@@ -14,9 +14,13 @@ export type GeneratePackageJsonArgs = {
      */
     packageJson: string;
     /**
-     * package.json of a sub package in the monorepo that you want to inherit properties from
+     * Path to a package.json that you want to inherit properties from.
+     *
+     * You might use this in a monorepo where all the dependencies are listed at the root but
+     * you have properties specific to one package in that package's directory that you want
+     * to preserve (such as engines, type, name, version, etc)
      */
-    childPackageJson?: string;
+    extendFrom?: string;
     /**
      * directory to check for used dependencies
      */
@@ -30,9 +34,9 @@ export async function generateSlimPackageJson(args: GeneratePackageJsonArgs) {
             encoding: 'utf8',
         }),
     ) as PackageJson;
-    const projectPackageJson = args.childPackageJson
+    const projectPackageJson = args.extendFrom
         ? (JSON.parse(
-              await readFile(path.resolve(args.childPackageJson), {
+              await readFile(path.resolve(args.extendFrom), {
                   encoding: 'utf8',
               }),
           ) as PackageJson)
@@ -73,7 +77,7 @@ export async function generateSlimPackageJson(args: GeneratePackageJsonArgs) {
     console.info(`Successfully wrote package.json to ${outputFile}`);
 }
 
-function addUsedDependencies(
+export function addUsedDependencies(
     fileContent: string,
     rootPackageJson: PackageJson,
     childPackageJson: PackageJson,
@@ -85,7 +89,7 @@ function addUsedDependencies(
             fileContent.includes(`from '${key}`) ||
             fileContent.includes(`from "${key}`) ||
             fileContent.includes(`require('${key}`) ||
-            fileContent.includes(`require("${key})`)
+            fileContent.includes(`require("${key}`)
         ) {
             if (!childPackageJson.dependencies) {
                 childPackageJson.dependencies = {};