@ontrails/trails 1.0.0-beta.3 → 1.0.0-beta.30

package/src/release/semver.ts

@@ -0,0 +1,104 @@
+/**
+ * Minimal semver comparison shared across release tooling.
+ *
+ * Extracted from `policy.ts` so the release policy engine and the registry
+ * classifier compare versions through one implementation instead of two.
+ */
+
+interface ParsedSemver {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+  readonly prerelease: string | undefined;
+}
+
+export const parseSemver = (version: string): ParsedSemver | undefined => {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u);
+  if (!match) {
+    return;
+  }
+  const [, major, minor, patch, prerelease] = match;
+  if (!major || !minor || !patch) {
+    return;
+  }
+  return {
+    major: Number.parseInt(major, 10),
+    minor: Number.parseInt(minor, 10),
+    patch: Number.parseInt(patch, 10),
+    prerelease,
+  };
+};
+
+const parsePrerelease = (value: string): (number | string)[] =>
+  value
+    .split('.')
+    .map((part) => (/^[0-9]+$/u.test(part) ? Number.parseInt(part, 10) : part));
+
+const comparePrerelease = (leftValue: string, rightValue: string): number => {
+  const left = parsePrerelease(leftValue);
+  const right = parsePrerelease(rightValue);
+  const length = Math.max(left.length, right.length);
+
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === undefined) {
+      return -1;
+    }
+    if (rightPart === undefined) {
+      return 1;
+    }
+    if (leftPart === rightPart) {
+      continue;
+    }
+    if (typeof leftPart === 'number' && typeof rightPart === 'number') {
+      return leftPart - rightPart;
+    }
+    if (typeof leftPart === 'number') {
+      return -1;
+    }
+    if (typeof rightPart === 'number') {
+      return 1;
+    }
+    const delta = leftPart.localeCompare(rightPart);
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+
+  return 0;
+};
+
+/**
+ * Compare two semver strings. Returns a negative number when `leftVersion`
+ * sorts before `rightVersion`, a positive number when it sorts after, and 0
+ * when equal. Unparseable inputs fall back to a locale comparison.
+ */
+export const compareSemver = (
+  leftVersion: string,
+  rightVersion: string
+): number => {
+  const left = parseSemver(leftVersion);
+  const right = parseSemver(rightVersion);
+  if (!left || !right) {
+    return leftVersion.localeCompare(rightVersion);
+  }
+
+  for (const key of ['major', 'minor', 'patch'] as const) {
+    const delta = left[key] - right[key];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+
+  if (left.prerelease === right.prerelease) {
+    return 0;
+  }
+  if (!left.prerelease) {
+    return 1;
+  }
+  if (!right.prerelease) {
+    return -1;
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+};

package/src/release/smoke.ts

@@ -0,0 +1,46 @@
+import { runPackedArtifactsSmoke } from './packed-artifacts-smoke.js';
+import type { PackedArtifactsSmokeResult } from './packed-artifacts-smoke.js';
+import { runWayfinderDogfoodSmoke } from './wayfinder-dogfood-smoke.js';
+import type { WayfinderDogfoodSmokeResult } from './wayfinder-dogfood-smoke.js';
+
+export const releaseSmokeCheckValues = [
+  'all',
+  'packed-artifacts',
+  'wayfinder-dogfood',
+] as const;
+export type ReleaseSmokeCheck = (typeof releaseSmokeCheckValues)[number];
+
+export type ReleaseSmokeCheckResult =
+  | PackedArtifactsSmokeResult
+  | WayfinderDogfoodSmokeResult;
+
+export interface ReleaseSmokeResult {
+  readonly checks: readonly ReleaseSmokeCheckResult[];
+  readonly message: string;
+  readonly passed: true;
+}
+
+const checksForInput = (
+  check: ReleaseSmokeCheck
+): readonly Exclude<ReleaseSmokeCheck, 'all'>[] =>
+  check === 'all' ? ['packed-artifacts', 'wayfinder-dogfood'] : [check];
+
+export const runReleaseSmoke = async (
+  check: ReleaseSmokeCheck
+): Promise<ReleaseSmokeResult> => {
+  const results: ReleaseSmokeCheckResult[] = [];
+
+  for (const selectedCheck of checksForInput(check)) {
+    if (selectedCheck === 'packed-artifacts') {
+      results.push(await runPackedArtifactsSmoke());
+      continue;
+    }
+    results.push(await runWayfinderDogfoodSmoke());
+  }
+
+  return {
+    checks: results,
+    message: results.map((result) => result.message).join('\n'),
+    passed: true,
+  };
+};