publish to NPM

Author: bcheidemann

.gitignore

@@ -0,0 +1 @@
+npm

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ben Heidemann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -6,13 +6,15 @@ Entype is a CLI tool and library which ingests serialized data formats
 
 ## Installation
 
+### Deno
+
 Entype can be installed using the Deno CLI:
 
 ```sh
 deno install --allow-read --allow-net https://deno.land/x/entype/main.ts
 ```
 
-And can then be run using the `entype` commands:
+And can then be run using the `entype` command:
 
 ```sh
 entype --lang rust fixtures/datapack/blockstates/*.json
@@ -25,6 +27,27 @@ command globally:
 deno run --allow-read https://deno.land/x/entype/main.ts --lang rust fixtures/datapack/blockstates/*.json
 ```
 
+### NPM
+
+Entype can be installed using NPM:
+
+```sh
+npm i -g typegen-json
+```
+
+And can then be run using the `typegen-json` command:
+
+```sh
+typegen-json --lang rust fixtures/datapack/blockstates/*.json
+```
+
+Alternatively, it can be run using NPX without the need to install the command
+globally:
+
+```sh
+npx typegen-json --lang rust fixtures/datapack/blockstates/*.json
+```
+
 ## Usage
 
 Entype accepts files to generate type definitions for and emits type definitions
@@ -364,6 +387,12 @@ to `main` and `path` defaults to `mod.ts`. The plugin speicifier
 `github:bcheidemann/entype-plugin-example` would be resolved to
 `https://raw.githubusercontent.com/bcheidemann/entype-plugin-example/main/mod.ts`.
 
+### Node.js
+
+For Node.js versions of entype (i.e. the one installed from NPM) plugins cannot
+be imported by URL. Instead, third party plugins must be published to NPM and
+can then be imported by their package name.
+
 ## How it works
 
 Entype tries to generate the simplest possible type that accurately describes

deno.jsonc

@@ -1,5 +1,9 @@
 {
   "tasks": {
-    "dev": "deno run --watch main.ts"
+    "dev": "deno run --allow-read=. --allow-write=. --allow-net main.ts",
+    "debug": "deno run --allow-read=. --allow-write=. --allow-net --inspect-brk main.ts",
+    "test": "deno test --allow-read=. --allow-write=.",
+    "bench": "deno bench --allow-read=. --allow-write=.",
+    "build:npm": "deno run --allow-read --allow-write --allow-env=DENO_DIR,XDG_CACHE_HOME,HOME,DENO_AUTH_TOKENS,XDG_DATA_HOME --allow-net=deno.land --allow-run=npm scripts/build-npm.ts"
   }
 }

deno.lock

@@ -0,0 +1,83 @@
+import "npm:@total-typescript/ts-reset";
+import { Json } from "../types.ts";
+import { parseJson } from "../parse.ts";
+import { collapseTypes } from "../collapse-types.ts";
+import { emitRootType } from "../emit/mod.ts";
+import { isPromiseFulfilledResult, isPromiseRejectedResult } from "./util.ts";
+import { loadPlugin } from "../plugins/mod.ts";
+import { getVersion } from "../version.ts";
+import { parseArgs } from "./parse-args.ts";
+
+export async function main(
+  runtime: "deno" | "node",
+  args: string[],
+): Promise<0 | 1> {
+  const config = parseArgs(args);
+
+  if ("help" in config) {
+    if (runtime === "deno") {
+      console.log(
+        "Usage: entype --lang <rust|typescript> [files]\n",
+      );
+    } else {
+      console.log(
+        "Usage: node typegen-json --lang <rust|typescript> [files]\n",
+      );
+    }
+
+    if ("message" in config) {
+      console.error(config.message);
+    }
+
+    if (config.invalidArgs) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+  if ("version" in config) {
+    console.log(getVersion());
+    return 0;
+  }
+
+  if ("lang" in config) {
+    let exitStatusCode: 0 | 1 = 0;
+
+    const types = await Promise.allSettled(
+      config.files.map(async (file) => {
+        const json = await Deno.readTextFile(file);
+        const obj = JSON.parse(json) as Json;
+        return parseJson(obj);
+      }),
+    );
+
+    if (types.some(isPromiseRejectedResult)) {
+      console.error([
+        "Failed to parse some files:",
+        ...types.map((result, i) => {
+          if (result.status === "fulfilled") {
+            return `  ${config.files[i]}: OK`;
+          } else {
+            return `  ${config.files[i]}: ${result.reason}`;
+          }
+        }),
+      ].join("\n"));
+      exitStatusCode = 1;
+    }
+
+    const type = collapseTypes(
+      types
+        .filter(isPromiseFulfilledResult)
+        .map((result) => result.value),
+    );
+
+    const plugins = await Promise.all(config.plugins.map(loadPlugin));
+
+    await emitRootType(config.lang, type, plugins, console.log);
+
+    return exitStatusCode;
+  }
+
+  throw new Error("Unreachable (received invalid config)");
+}

lib/cli/main.ts

@@ -1 +1 @@
-export { parseArgs } from "./parse-args.ts";
+export * from "./main.ts";

lib/cli/mod.ts

@@ -0,0 +1,8 @@
+export * from "./cli/mod.ts";
+export * from "./emit/mod.ts";
+export * from "./plugins/mod.ts";
+export * from "./collapse-types.ts";
+export * from "./parse.ts";
+export * from "./type-guards.ts";
+export * from "./util.ts";
+export * from "./version.ts";

util.ts renamed to lib/cli/util.ts

@@ -0,0 +1,3 @@
+export function getVersion() {
+  return "1.2.2";
+}