runtime-resolver 0.3.22 → 1.0.0

package/schemas/node-schedule.js

@@ -1,110 +0,0 @@
-import { Data, DateTime, Effect, Option } from "effect";
-
-//#region src/schemas/node-schedule.ts
-/**
-* Immutable snapshot of the Node.js release schedule.
-*
-* Holds a `ReadonlyArray<NodeScheduleEntry>` parsed from the raw
-* {@link NodeScheduleData} fetched by {@link NodeScheduleFetcher}. A single
-* `NodeSchedule` instance lives inside a `Ref<NodeSchedule>` that is shared
-* across all {@link NodeRelease} instances so that schedule updates propagate
-* without rebuilding the release cache.
-*
-* `NodeSchedule` extends `Data.TaggedClass` and therefore supports structural
-* equality — two schedules built from identical data compare as equal.
-*
-* @see {@link NodeRelease}
-* @see {@link NodeScheduleFetcher}
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { NodePhase } from "./common.js";
-* import type { NodeScheduleData } from "./node-schedule.js";
-* import { NodeSchedule } from "./node-schedule.js";
-*
-* const data: NodeScheduleData = {
-*   v20: {
-*     start: "2023-04-18",
-*     lts: "2023-10-24",
-*     maintenance: "2024-10-22",
-*     end: "2026-04-30",
-*     codename: "Iron",
-*   },
-* };
-*
-* const schedule = NodeSchedule.fromData(data);
-*
-* const program = schedule.phaseFor(20, new Date("2024-01-01") as any).pipe(
-*   Effect.map((phase: NodePhase | null) => {
-*     console.log(phase); // "active-lts"
-*   }),
-* );
-*
-* Effect.runPromise(program);
-* ```
-*
-* @public
-*/
-var NodeSchedule = class NodeSchedule extends Data.TaggedClass("NodeSchedule") {
-	/**
-	* Parse raw {@link NodeScheduleData} into a `NodeSchedule` instance.
-	*
-	* Iterates over every key of the form `"vNN"`, converts ISO date strings
-	* to `DateTime.DateTime`, and normalises missing codenames to `""`.
-	*
-	* @param data - The raw JSON object fetched from the Node.js release repo.
-	* @returns A fully constructed, immutable `NodeSchedule`.
-	*/
-	static fromData(data) {
-		const entries = [];
-		for (const [key, value] of Object.entries(data)) {
-			const major = Number.parseInt(key.replace("v", ""), 10);
-			if (Number.isNaN(major)) continue;
-			entries.push({
-				major,
-				start: DateTime.unsafeMake(value.start),
-				lts: value.lts ? DateTime.unsafeMake(value.lts) : null,
-				maintenance: value.maintenance ? DateTime.unsafeMake(value.maintenance) : null,
-				end: DateTime.unsafeMake(value.end),
-				codename: value.codename ?? ""
-			});
-		}
-		return new NodeSchedule({ entries });
-	}
-	/**
-	* Determine the current {@link (NodePhase:type)} for a given major version number
-	* at the specified point in time.
-	*
-	* Returns `null` when the major is not present in the schedule or when
-	* `now` is before the release's start date.
-	*
-	* @param major - The Node.js major version number (e.g. `20`).
-	* @param now - The reference `DateTime` against which phases are evaluated.
-	*/
-	phaseFor(major, now) {
-		return Effect.sync(() => {
-			const entry = this.entries.find((e) => e.major === major);
-			if (!entry) return null;
-			if (DateTime.lessThan(now, entry.start)) return null;
-			if (DateTime.greaterThanOrEqualTo(now, entry.end)) return "end-of-life";
-			if (entry.maintenance && DateTime.greaterThanOrEqualTo(now, entry.maintenance)) return "maintenance-lts";
-			if (entry.lts && DateTime.greaterThanOrEqualTo(now, entry.lts)) return "active-lts";
-			return "current";
-		});
-	}
-	/**
-	* Look up the {@link NodeScheduleEntry} for a given major version number.
-	*
-	* Returns `Option.none()` when the major is not present in the schedule.
-	*
-	* @param major - The Node.js major version number (e.g. `20`).
-	*/
-	entryFor(major) {
-		const entry = this.entries.find((e) => e.major === major);
-		return entry ? Option.some(entry) : Option.none();
-	}
-};
-
-//#endregion
-export { NodeSchedule };

package/schemas/node.js

@@ -1,68 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/schemas/node.ts
-/**
-* A single entry in the Node.js distribution index
-* (`https://nodejs.org/dist/index.json`).
-*
-* Decoded by {@link NodeVersionFetcherLive} when fetching the full list of
-* available Node.js releases from the official distribution server.
-*
-* @internal
-*/
-const NodeDistVersion = Schema.Struct({
-	version: Schema.String,
-	date: Schema.String,
-	files: Schema.Array(Schema.String),
-	npm: Schema.optional(Schema.String),
-	v8: Schema.optional(Schema.String),
-	uv: Schema.optional(Schema.String),
-	zlib: Schema.optional(Schema.String),
-	openssl: Schema.optional(Schema.String),
-	modules: Schema.optional(Schema.String),
-	lts: Schema.Union(Schema.Literal(false), Schema.String),
-	security: Schema.Boolean
-});
-/**
-* The full decoded body of `https://nodejs.org/dist/index.json`.
-*
-* Decoded by {@link NodeVersionFetcherLive} before being mapped into
-* {@link NodeRelease} instances.
-*
-* @internal
-*/
-const NodeDistIndex = Schema.Array(NodeDistVersion);
-/**
-* A single entry in the Node.js release schedule JSON fetched by
-* {@link NodeScheduleFetcherLive}.
-*
-* All date-like fields are optional because odd-numbered major lines
-* (e.g. v21) never enter LTS.
-*
-* @internal
-*/
-const ReleaseScheduleEntry = Schema.Struct({
-	start: Schema.String,
-	lts: Schema.optional(Schema.String),
-	maintenance: Schema.optional(Schema.String),
-	end: Schema.String,
-	codename: Schema.optional(Schema.String)
-});
-/**
-* The full decoded body of the Node.js release schedule JSON fetched by
-* {@link NodeScheduleFetcherLive}.
-*
-* Keyed by major version string (e.g. `"v20"`); values are
-* {@link ReleaseScheduleEntry} objects. After decoding, this record is handed
-* to {@link NodeSchedule.fromData} to produce an immutable
-* {@link NodeSchedule}.
-*
-* @internal
-*/
-const NodeReleaseSchedule = Schema.Record({
-	key: Schema.String,
-	value: ReleaseScheduleEntry
-});
-
-//#endregion
-export { NodeDistIndex, NodeDistVersion, NodeReleaseSchedule, ReleaseScheduleEntry };

package/services/BunReleaseCache.js

@@ -1,33 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/BunReleaseCache.ts
-/**
-* Specialisation of {@link RuntimeCache} for Bun release objects.
-*
-* @example
-* ```typescript
-* import type { BunRelease } from "runtime-resolver";
-* import { BunReleaseCache, OfflineBunCacheLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const cache = yield* BunReleaseCache;
-* 	const releases = yield* cache.releases();
-* 	console.log(releases.length);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(OfflineBunCacheLive)));
-* ```
-*
-* @see {@link BunRelease}
-* @see {@link RuntimeCache}
-* @see {@link AutoBunCacheLive}
-* @see {@link FreshBunCacheLive}
-* @see {@link OfflineBunCacheLive}
-*
-* @public
-*/
-var BunReleaseCache = class extends Context.Tag("runtime-resolver/BunReleaseCache")() {};
-
-//#endregion
-export { BunReleaseCache };

package/services/BunResolver.js

@@ -1,36 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/BunResolver.ts
-/**
-* Service for resolving Bun runtime versions against the cached
-* release index.
-*
-* For a one-shot Promise-based API see {@link resolveBun}.
-*
-* @example
-* ```typescript
-* import type { ResolvedVersions } from "runtime-resolver";
-* import { BunResolver, BunResolverLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const resolver = yield* BunResolver;
-* 	const result = yield* resolver.resolve({ semverRange: "^1.0.0", increments: "minor" });
-* 	console.log(result.latest);
-* 	console.log(result.versions);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(BunResolverLive)));
-* ```
-*
-* @see {@link BunResolverLive}
-* @see {@link resolveBun}
-* @see {@link BunResolverOptions}
-* @see {@link (ResolvedVersions:type)}
-*
-* @public
-*/
-var BunResolver = class extends Context.Tag("runtime-resolver/BunResolver")() {};
-
-//#endregion
-export { BunResolver };

package/services/BunVersionFetcher.js

@@ -1,41 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/BunVersionFetcher.ts
-/**
-* Service for fetching Bun release data from the GitHub API.
-*
-* Retrieves both the parsed semver version list and the raw release input
-* records needed to populate a {@link BunReleaseCache}. The live
-* implementation queries the `oven-sh/bun` GitHub repository via
-* {@link GitHubClient}.
-*
-* @example
-* ```typescript
-* import type { RuntimeReleaseInput } from "runtime-resolver";
-* import { BunVersionFetcher, BunVersionFetcherLive, GitHubAutoAuth } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const fetcher = yield* BunVersionFetcher;
-* 	const { versions, inputs } = yield* fetcher.fetch();
-* 	console.log(`Fetched ${versions.length} Bun releases`);
-* });
-*
-* Effect.runPromise(
-* 	program.pipe(Effect.provide(BunVersionFetcherLive), Effect.provide(GitHubAutoAuth)),
-* );
-* ```
-*
-* @see {@link BunVersionFetcherLive}
-* @see {@link BunReleaseCache}
-* @see {@link AuthenticationError}
-* @see {@link NetworkError}
-* @see {@link ParseError}
-* @see {@link RateLimitError}
-*
-* @public
-*/
-var BunVersionFetcher = class extends Context.Tag("runtime-resolver/BunVersionFetcher")() {};
-
-//#endregion
-export { BunVersionFetcher };

package/services/DenoReleaseCache.js

@@ -1,33 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/DenoReleaseCache.ts
-/**
-* Specialisation of {@link RuntimeCache} for Deno release objects.
-*
-* @example
-* ```typescript
-* import type { DenoRelease } from "runtime-resolver";
-* import { DenoReleaseCache, OfflineDenoCacheLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const cache = yield* DenoReleaseCache;
-* 	const latest = yield* cache.latest();
-* 	console.log(latest.version.toString());
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(OfflineDenoCacheLive)));
-* ```
-*
-* @see {@link DenoRelease}
-* @see {@link RuntimeCache}
-* @see {@link AutoDenoCacheLive}
-* @see {@link FreshDenoCacheLive}
-* @see {@link OfflineDenoCacheLive}
-*
-* @public
-*/
-var DenoReleaseCache = class extends Context.Tag("runtime-resolver/DenoReleaseCache")() {};
-
-//#endregion
-export { DenoReleaseCache };

package/services/DenoResolver.js

@@ -1,36 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/DenoResolver.ts
-/**
-* Service for resolving Deno runtime versions against the cached
-* release index.
-*
-* For a one-shot Promise-based API see {@link resolveDeno}.
-*
-* @example
-* ```typescript
-* import type { ResolvedVersions } from "runtime-resolver";
-* import { DenoResolver, DenoResolverLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const resolver = yield* DenoResolver;
-* 	const result = yield* resolver.resolve({ semverRange: "^2.0.0", increments: "minor" });
-* 	console.log(result.latest);
-* 	console.log(result.versions);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(DenoResolverLive)));
-* ```
-*
-* @see {@link DenoResolverLive}
-* @see {@link resolveDeno}
-* @see {@link DenoResolverOptions}
-* @see {@link (ResolvedVersions:type)}
-*
-* @public
-*/
-var DenoResolver = class extends Context.Tag("runtime-resolver/DenoResolver")() {};
-
-//#endregion
-export { DenoResolver };

package/services/DenoVersionFetcher.js

@@ -1,41 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/DenoVersionFetcher.ts
-/**
-* Service for fetching Deno release data from the GitHub API.
-*
-* Retrieves both the parsed semver version list and the raw release input
-* records needed to populate a {@link DenoReleaseCache}. The live
-* implementation queries the `denoland/deno` GitHub repository via
-* {@link GitHubClient}.
-*
-* @example
-* ```typescript
-* import type { RuntimeReleaseInput } from "runtime-resolver";
-* import { DenoVersionFetcher, DenoVersionFetcherLive, GitHubAutoAuth } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const fetcher = yield* DenoVersionFetcher;
-* 	const { versions, inputs } = yield* fetcher.fetch();
-* 	console.log(`Fetched ${versions.length} Deno releases`);
-* });
-*
-* Effect.runPromise(
-* 	program.pipe(Effect.provide(DenoVersionFetcherLive), Effect.provide(GitHubAutoAuth)),
-* );
-* ```
-*
-* @see {@link DenoVersionFetcherLive}
-* @see {@link DenoReleaseCache}
-* @see {@link AuthenticationError}
-* @see {@link NetworkError}
-* @see {@link ParseError}
-* @see {@link RateLimitError}
-*
-* @public
-*/
-var DenoVersionFetcher = class extends Context.Tag("runtime-resolver/DenoVersionFetcher")() {};
-
-//#endregion
-export { DenoVersionFetcher };

package/services/GitHubClient.js

@@ -1,40 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/GitHubClient.ts
-/**
-* Service for GitHub REST API operations used by the version
-* fetcher services.
-*
-* Abstracts over pagination and authentication so that higher-level services
-* such as {@link BunVersionFetcher}, {@link DenoVersionFetcher}, and
-* {@link NodeScheduleFetcher} remain independent of the underlying HTTP
-* transport. The live implementation is provided by {@link GitHubClientLive}
-* and requires an {@link OctokitInstance} in its dependency graph.
-*
-* @example
-* ```typescript
-* import type { GitHubTag } from "runtime-resolver";
-* import { GitHubClient, GitHubClientLive, GitHubAutoAuth } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const client = yield* GitHubClient;
-* 	const tags = yield* client.listTags("oven-sh", "bun", { perPage: 100 });
-* 	console.log(`Found ${tags.length} tags`);
-* });
-*
-* Effect.runPromise(
-* 	program.pipe(Effect.provide(GitHubClientLive), Effect.provide(GitHubAutoAuth)),
-* );
-* ```
-*
-* @see {@link GitHubClientLive}
-* @see {@link OctokitInstance}
-* @see {@link ListOptions}
-*
-* @public
-*/
-var GitHubClient = class extends Context.Tag("runtime-resolver/GitHubClient")() {};
-
-//#endregion
-export { GitHubClient };

package/services/NodeReleaseCache.js

@@ -1,41 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/NodeReleaseCache.ts
-/**
-* Node.js-specific cache service that extends {@link RuntimeCache} with
-* additional operations for lifecycle schedule data and LTS / current
-* release filtering.
-*
-* Unlike the Bun and Deno equivalents this service is not a plain type alias
-* — it adds four Node-specific methods on top of the generic cache contract.
-*
-* @example
-* ```typescript
-* import type { NodeRelease } from "runtime-resolver";
-* import { NodeReleaseCache, OfflineNodeCacheLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const cache = yield* NodeReleaseCache;
-* 	const lts = yield* cache.ltsReleases();
-* 	for (const release of lts) {
-* 		console.log(release.version.toString(), release.phase);
-* 	}
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(OfflineNodeCacheLive)));
-* ```
-*
-* @see {@link NodeRelease}
-* @see {@link NodeScheduleData}
-* @see {@link RuntimeCache}
-* @see {@link AutoNodeCacheLive}
-* @see {@link FreshNodeCacheLive}
-* @see {@link OfflineNodeCacheLive}
-*
-* @public
-*/
-var NodeReleaseCache = class extends Context.Tag("runtime-resolver/NodeReleaseCache")() {};
-
-//#endregion
-export { NodeReleaseCache };

package/services/NodeResolver.js

@@ -1,44 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/NodeResolver.ts
-/**
-* Service for resolving Node.js runtime versions against the cached
-* release index.
-*
-* Unlike {@link BunResolver} and {@link DenoResolver}, this service is
-* lifecycle-aware: results can be filtered by {@link (NodePhase:type)} and evaluated
-* against a specific reference date.
-*
-* For a one-shot Promise-based API see {@link resolveNode}.
-*
-* @example
-* ```typescript
-* import type { ResolvedVersions } from "runtime-resolver";
-* import { NodeResolver, NodeResolverLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const resolver = yield* NodeResolver;
-* 	const result = yield* resolver.resolve({
-* 		semverRange: "^20.0.0",
-* 		phases: ["active-lts"],
-* 		increments: "minor",
-* 	});
-* 	console.log(result.latest);
-* 	console.log(result.lts);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(NodeResolverLive)));
-* ```
-*
-* @see {@link NodeResolverLive}
-* @see {@link resolveNode}
-* @see {@link NodeResolverOptions}
-* @see {@link (ResolvedVersions:type)}
-*
-* @public
-*/
-var NodeResolver = class extends Context.Tag("runtime-resolver/NodeResolver")() {};
-
-//#endregion
-export { NodeResolver };

package/services/NodeScheduleFetcher.js

@@ -1,38 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/NodeScheduleFetcher.ts
-/**
-* Service for fetching the official Node.js release schedule.
-*
-* The schedule maps each major release line to its LTS start date and
-* end-of-life date, and is used by {@link NodeReleaseCache} to assign
-* lifecycle phases to individual releases. The live implementation fetches
-* from the `nodejs/Release` GitHub repository via a plain HTTP request.
-*
-* @example
-* ```typescript
-* import type { NodeScheduleData } from "runtime-resolver";
-* import { NodeScheduleFetcher, NodeScheduleFetcherLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const fetcher = yield* NodeScheduleFetcher;
-* 	const schedule = yield* fetcher.fetch();
-* 	console.log(Object.keys(schedule).length, "major release lines");
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(NodeScheduleFetcherLive)));
-* ```
-*
-* @see {@link NodeScheduleFetcherLive}
-* @see {@link NodeReleaseCache}
-* @see {@link NodeScheduleData}
-* @see {@link NetworkError}
-* @see {@link ParseError}
-*
-* @public
-*/
-var NodeScheduleFetcher = class extends Context.Tag("runtime-resolver/NodeScheduleFetcher")() {};
-
-//#endregion
-export { NodeScheduleFetcher };

package/services/NodeVersionFetcher.js

@@ -1,39 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/NodeVersionFetcher.ts
-/**
-* Service for fetching Node.js release data from the official
-* Node.js distribution index.
-*
-* Retrieves both the parsed semver version list and the raw
-* {@link (NodeReleaseInput:type)} records needed to populate a
-* {@link NodeReleaseCache}. The live implementation fetches from
-* `https://nodejs.org/dist/index.json` via a plain HTTP request — no GitHub
-* credentials are required.
-*
-* @example
-* ```typescript
-* import type { NodeReleaseInput } from "runtime-resolver";
-* import { NodeVersionFetcher, NodeVersionFetcherLive } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const fetcher = yield* NodeVersionFetcher;
-* 	const { versions, inputs } = yield* fetcher.fetch();
-* 	console.log(`Fetched ${versions.length} Node.js releases`);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(NodeVersionFetcherLive)));
-* ```
-*
-* @see {@link NodeVersionFetcherLive}
-* @see {@link NodeReleaseCache}
-* @see {@link NetworkError}
-* @see {@link ParseError}
-*
-* @public
-*/
-var NodeVersionFetcher = class extends Context.Tag("runtime-resolver/NodeVersionFetcher")() {};
-
-//#endregion
-export { NodeVersionFetcher };

package/services/OctokitInstance.js

@@ -1,44 +0,0 @@
-import { Context } from "effect";
-
-//#region src/services/OctokitInstance.ts
-/**
-* Thin wrapper around the subset of Octokit's REST client used by
-* {@link GitHubClient}.
-*
-* Exposing only the repository methods actually consumed by this library
-* keeps the surface area narrow and makes the interface straightforward to
-* stub in tests without pulling in the full Octokit type.
-*
-* An `OctokitInstance` is provided to the dependency graph by one of the
-* three authentication layers: {@link GitHubTokenAuth}, {@link GitHubAppAuth},
-* or {@link GitHubAutoAuth}.
-*
-* @example
-* ```typescript
-* import { OctokitInstance, GitHubClientLive, GitHubAutoAuth } from "runtime-resolver";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-* 	const octokit = yield* OctokitInstance;
-* 	const response = await octokit.rest.repos.listTags({
-* 		owner: "oven-sh",
-* 		repo: "bun",
-* 		per_page: 10,
-* 	});
-* 	console.log(response.data.length);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(GitHubAutoAuth)));
-* ```
-*
-* @see {@link GitHubClientLive}
-* @see {@link GitHubTokenAuth}
-* @see {@link GitHubAppAuth}
-* @see {@link GitHubAutoAuth}
-*
-* @public
-*/
-var OctokitInstance = class extends Context.Tag("runtime-resolver/OctokitInstance")() {};
-
-//#endregion
-export { OctokitInstance };

package/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.9"
-    }
-  ]
-}