@ricsam/isolate-types 0.0.1 → 0.1.3

package/README.md

@@ -1,45 +1,88 @@
 # @ricsam/isolate-types
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/isolate-types`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+Type definitions and type-checking utilities for isolate user code.
+
+```bash
+npm add @ricsam/isolate-types
+```
+
+#### Type Checking Isolate Code
+
+Validate TypeScript/JavaScript code that will run inside the isolate before execution using `ts-morph`:
+
+```typescript
+import { typecheckIsolateCode } from "@ricsam/isolate-types";
+
+const result = typecheckIsolateCode(`
+  serve({
+    fetch(request, server) {
+      const url = new URL(request.url);
+
+      if (url.pathname === "/ws") {
+        server.upgrade(request, { data: { userId: 123 } });
+        return new Response(null, { status: 101 });
+      }
+
+      return Response.json({ message: "Hello!" });
+    },
+    websocket: {
+      message(ws, message) {
+        ws.send("Echo: " + message);
+      }
+    }
+  });
+`, { include: ["core", "fetch"] });
+
+if (!result.success) {
+  console.error("Type errors found:");
+  for (const error of result.errors) {
+    console.error(`  Line ${error.line}: ${error.message}`);
+  }
+}
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `include` | Which package types to include: `"core"`, `"fetch"`, `"fs"`, `"console"`, `"encoding"`, `"timers"`, `"testEnvironment"` (default: `["core", "fetch", "fs"]`) |
+| `compilerOptions` | Additional TypeScript compiler options |
+| `libraryTypes` | External library type definitions for import resolution (for validating user imports) |
+
+**Using with tests:**
+
+```typescript
+import { describe, expect, test } from "node:test";
+import { typecheckIsolateCode } from "@ricsam/isolate-types";
+
+describe("Isolate code validation", () => {
+  test("server code is type-safe", () => {
+    const result = typecheckIsolateCode(userProvidedCode, {
+      include: ["fetch"]
+    });
+    expect(result.success).toBe(true);
+  });
+});
+```
+
+#### Type Definition Strings
+
+The type definitions are exported as strings for custom use cases:
+
+```typescript
+import {
+  CORE_TYPES,      // ReadableStream, Blob, File, URL, etc.
+  CONSOLE_TYPES,   // console.log, console.time, etc.
+  CRYPTO_TYPES,    // crypto.subtle, CryptoKey, etc.
+  ENCODING_TYPES,  // atob, btoa
+  FETCH_TYPES,     // fetch, Request, Response, serve, etc.
+  FS_TYPES,        // getDirectory, FileSystemHandle, etc.
+  PATH_TYPES,      // path.join, path.resolve, etc.
+  TEST_ENV_TYPES,  // describe, it, expect, etc.
+  TIMERS_TYPES,    // setTimeout, setInterval, etc.
+  TYPE_DEFINITIONS // All types as { core, fetch, fs, ... }
+} from "@ricsam/isolate-types";
+
+// Use with your own ts-morph project
+project.createSourceFile("isolate-globals.d.ts", FETCH_TYPES);
+```

package/dist/cjs/index.cjs

@@ -0,0 +1,51 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/isolate-types/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  typecheckIsolateCode: () => import_typecheck.typecheckIsolateCode,
+  formatTypecheckErrors: () => import_typecheck.formatTypecheckErrors,
+  TYPE_DEFINITIONS: () => import_isolate_types.TYPE_DEFINITIONS,
+  TIMERS_TYPES: () => import_isolate_types.TIMERS_TYPES,
+  TEST_ENV_TYPES: () => import_isolate_types.TEST_ENV_TYPES,
+  PATH_TYPES: () => import_isolate_types.PATH_TYPES,
+  FS_TYPES: () => import_isolate_types.FS_TYPES,
+  FETCH_TYPES: () => import_isolate_types.FETCH_TYPES,
+  ENCODING_TYPES: () => import_isolate_types.ENCODING_TYPES,
+  CRYPTO_TYPES: () => import_isolate_types.CRYPTO_TYPES,
+  CORE_TYPES: () => import_isolate_types.CORE_TYPES,
+  CONSOLE_TYPES: () => import_isolate_types.CONSOLE_TYPES
+});
+module.exports = __toCommonJS(exports_src);
+var import_isolate_types = require("./isolate-types.cjs");
+var import_typecheck = require("./typecheck.cjs");
+})
+
+//# debugId=1488BE7FB67324F264756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * @ricsam/isolate-types\n *\n * Type definitions and type-checking utilities for isolated-vm V8 sandbox code.\n */\n\n// Re-export type definitions\nexport {\n  CORE_TYPES,\n  CONSOLE_TYPES,\n  CRYPTO_TYPES,\n  ENCODING_TYPES,\n  FETCH_TYPES,\n  FS_TYPES,\n  PATH_TYPES,\n  TEST_ENV_TYPES,\n  TIMERS_TYPES,\n  TYPE_DEFINITIONS,\n  type TypeDefinitionKey,\n} from \"./isolate-types.cjs\";\n\n// Re-export typecheck utilities\nexport {\n  typecheckIsolateCode,\n  formatTypecheckErrors,\n  type TypecheckResult,\n  type TypecheckError,\n  type TypecheckOptions,\n  type LibraryTypes,\n  type LibraryTypeFile,\n} from \"./typecheck.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBO,IAZP;AAuBO,IARP;",
+  "debugId": "1488BE7FB67324F264756E2164756E21",
+  "names": []
+}