forgeos 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/forge/compiler/primitives/paths.ts

@@ -1,24 +1,24 @@
-import { compareBytes } from "./compare.ts";
-
-/**
- * Normalize a path to workspace-relative POSIX form with `/` separators.
- */
-export function normalizePath(path: string): string {
-  let normalized = path.replace(/\\/g, "/");
-
-  while (normalized.startsWith("./")) {
-    normalized = normalized.slice(2);
-  }
-
-  normalized = normalized.replace(/\/+/g, "/");
-
-  if (normalized.length > 1 && normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1);
-  }
-
-  return normalized;
-}
-
-export function comparePaths(a: string, b: string): number {
-  return compareBytes(normalizePath(a), normalizePath(b));
-}
+import { compareBytes } from "./compare.ts";
+
+/**
+ * Normalize a path to workspace-relative POSIX form with `/` separators.
+ */
+export function normalizePath(path: string): string {
+  let normalized = path.replace(/\\/g, "/");
+
+  while (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+
+  normalized = normalized.replace(/\/+/g, "/");
+
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+
+  return normalized;
+}
+
+export function comparePaths(a: string, b: string): number {
+  return compareBytes(normalizePath(a), normalizePath(b));
+}

package/src/forge/compiler/primitives/serialize.ts

@@ -1,66 +1,66 @@
-import type { JsonValue } from "../types/json.ts";
-import { compareBytes } from "./compare.ts";
-
-/**
- * Normalize line endings to LF and ensure exactly one trailing newline.
- */
-export function normalizeNewlines(content: string): string {
-  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  if (normalized.length === 0) {
-    return "\n";
-  }
-  return normalized.endsWith("\n") ? normalized : `${normalized}\n`;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    Object.getPrototypeOf(value) === Object.prototype
-  );
-}
-
-function sortObjectKeys(value: Record<string, unknown>): Record<string, unknown> {
-  const sorted: Record<string, unknown> = {};
-  const keys = Object.keys(value).sort(compareBytes);
-  for (const key of keys) {
-    sorted[key] = canonicalizeValue(value[key]);
-  }
-  return sorted;
-}
-
-function canonicalizeValue(value: unknown): unknown {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    return value.map(canonicalizeValue);
-  }
-
-  if (isPlainObject(value)) {
-    return sortObjectKeys(value);
-  }
-
-  return value;
-}
-
-/**
- * Serialize a value to canonical JSON with stable key ordering.
- */
-export function canonicalJson(value: unknown): string {
-  const canonical = canonicalizeValue(value);
-  return JSON.stringify(canonical);
-}
-
-/**
- * Serialize to canonical JSON with normalized newlines and trailing newline.
- */
-export function serializeCanonical(value: unknown): string {
-  return normalizeNewlines(canonicalJson(value));
-}
-
-export function serializeJsonValue(value: JsonValue): string {
-  return serializeCanonical(value);
-}
+import type { JsonValue } from "../types/json.ts";
+import { compareBytes } from "./compare.ts";
+
+/**
+ * Normalize line endings to LF and ensure exactly one trailing newline.
+ */
+export function normalizeNewlines(content: string): string {
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (normalized.length === 0) {
+    return "\n";
+  }
+  return normalized.endsWith("\n") ? normalized : `${normalized}\n`;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype
+  );
+}
+
+function sortObjectKeys(value: Record<string, unknown>): Record<string, unknown> {
+  const sorted: Record<string, unknown> = {};
+  const keys = Object.keys(value).sort(compareBytes);
+  for (const key of keys) {
+    sorted[key] = canonicalizeValue(value[key]);
+  }
+  return sorted;
+}
+
+function canonicalizeValue(value: unknown): unknown {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(canonicalizeValue);
+  }
+
+  if (isPlainObject(value)) {
+    return sortObjectKeys(value);
+  }
+
+  return value;
+}
+
+/**
+ * Serialize a value to canonical JSON with stable key ordering.
+ */
+export function canonicalJson(value: unknown): string {
+  const canonical = canonicalizeValue(value);
+  return JSON.stringify(canonical);
+}
+
+/**
+ * Serialize to canonical JSON with normalized newlines and trailing newline.
+ */
+export function serializeCanonical(value: unknown): string {
+  return normalizeNewlines(canonicalJson(value));
+}
+
+export function serializeJsonValue(value: JsonValue): string {
+  return serializeCanonical(value);
+}

package/src/forge/compiler/primitives/sort.ts

@@ -1,87 +1,87 @@
-import type { ForgeEdge, ForgeSymbol } from "../types/app-graph.ts";
-import type { EmitFile } from "../types/emit.ts";
-import type {
-  Entrypoint,
-  ExportSignature,
-  PackageApi,
-} from "../types/package-graph.ts";
-import { compareBytes } from "./compare.ts";
-import { comparePaths } from "./paths.ts";
-
-function stableSortInPlace<T>(items: T[], compare: (a: T, b: T) => number): T[] {
-  items.sort(compare);
-  return items;
-}
-
-export function compareSymbols(a: ForgeSymbol, b: ForgeSymbol): number {
-  let cmp = compareBytes(a.kind, b.kind);
-  if (cmp !== 0) return cmp;
-
-  cmp = compareBytes(a.name, b.name);
-  if (cmp !== 0) return cmp;
-
-  cmp = comparePaths(a.file, b.file);
-  if (cmp !== 0) return cmp;
-
-  return a.span.start - b.span.start;
-}
-
-export function compareEdges(a: ForgeEdge, b: ForgeEdge): number {
-  let cmp = compareBytes(a.from, b.from);
-  if (cmp !== 0) return cmp;
-
-  cmp = compareBytes(a.to, b.to);
-  if (cmp !== 0) return cmp;
-
-  return compareBytes(a.kind, b.kind);
-}
-
-export function comparePackages(a: PackageApi, b: PackageApi): number {
-  return compareBytes(a.name, b.name);
-}
-
-export function compareEntrypoints(a: Entrypoint, b: Entrypoint): number {
-  return compareBytes(a.subpath, b.subpath);
-}
-
-export function compareExports(a: ExportSignature, b: ExportSignature): number {
-  return compareBytes(a.name, b.name);
-}
-
-export function compareEmitFiles(a: EmitFile, b: EmitFile): number {
-  return comparePaths(a.path, b.path);
-}
-
-export function stableSortSymbols(symbols: ForgeSymbol[]): ForgeSymbol[] {
-  return stableSortInPlace([...symbols], compareSymbols);
-}
-
-export function stableSortEdges(edges: ForgeEdge[]): ForgeEdge[] {
-  return stableSortInPlace([...edges], compareEdges);
-}
-
-export function stableSortPackages(packages: PackageApi[]): PackageApi[] {
-  return stableSortInPlace([...packages], comparePackages);
-}
-
-export function stableSortEntrypoints(
-  entrypoints: Entrypoint[],
-): Entrypoint[] {
-  return stableSortInPlace([...entrypoints], compareEntrypoints);
-}
-
-export function stableSortExports(exports: ExportSignature[]): ExportSignature[] {
-  return stableSortInPlace([...exports], compareExports);
-}
-
-export function stableSortEmitFiles(files: EmitFile[]): EmitFile[] {
-  return stableSortInPlace([...files], compareEmitFiles);
-}
-
-export function stableSortStrings(items: string[]): string[] {
-  return stableSortInPlace([...items], compareBytes);
-}
-
-export function stableSortByPath(items: string[]): string[] {
-  return stableSortInPlace([...items], comparePaths);
-}
+import type { ForgeEdge, ForgeSymbol } from "../types/app-graph.ts";
+import type { EmitFile } from "../types/emit.ts";
+import type {
+  Entrypoint,
+  ExportSignature,
+  PackageApi,
+} from "../types/package-graph.ts";
+import { compareBytes } from "./compare.ts";
+import { comparePaths } from "./paths.ts";
+
+function stableSortInPlace<T>(items: T[], compare: (a: T, b: T) => number): T[] {
+  items.sort(compare);
+  return items;
+}
+
+export function compareSymbols(a: ForgeSymbol, b: ForgeSymbol): number {
+  let cmp = compareBytes(a.kind, b.kind);
+  if (cmp !== 0) return cmp;
+
+  cmp = compareBytes(a.name, b.name);
+  if (cmp !== 0) return cmp;
+
+  cmp = comparePaths(a.file, b.file);
+  if (cmp !== 0) return cmp;
+
+  return a.span.start - b.span.start;
+}
+
+export function compareEdges(a: ForgeEdge, b: ForgeEdge): number {
+  let cmp = compareBytes(a.from, b.from);
+  if (cmp !== 0) return cmp;
+
+  cmp = compareBytes(a.to, b.to);
+  if (cmp !== 0) return cmp;
+
+  return compareBytes(a.kind, b.kind);
+}
+
+export function comparePackages(a: PackageApi, b: PackageApi): number {
+  return compareBytes(a.name, b.name);
+}
+
+export function compareEntrypoints(a: Entrypoint, b: Entrypoint): number {
+  return compareBytes(a.subpath, b.subpath);
+}
+
+export function compareExports(a: ExportSignature, b: ExportSignature): number {
+  return compareBytes(a.name, b.name);
+}
+
+export function compareEmitFiles(a: EmitFile, b: EmitFile): number {
+  return comparePaths(a.path, b.path);
+}
+
+export function stableSortSymbols(symbols: ForgeSymbol[]): ForgeSymbol[] {
+  return stableSortInPlace([...symbols], compareSymbols);
+}
+
+export function stableSortEdges(edges: ForgeEdge[]): ForgeEdge[] {
+  return stableSortInPlace([...edges], compareEdges);
+}
+
+export function stableSortPackages(packages: PackageApi[]): PackageApi[] {
+  return stableSortInPlace([...packages], comparePackages);
+}
+
+export function stableSortEntrypoints(
+  entrypoints: Entrypoint[],
+): Entrypoint[] {
+  return stableSortInPlace([...entrypoints], compareEntrypoints);
+}
+
+export function stableSortExports(exports: ExportSignature[]): ExportSignature[] {
+  return stableSortInPlace([...exports], compareExports);
+}
+
+export function stableSortEmitFiles(files: EmitFile[]): EmitFile[] {
+  return stableSortInPlace([...files], compareEmitFiles);
+}
+
+export function stableSortStrings(items: string[]): string[] {
+  return stableSortInPlace([...items], compareBytes);
+}
+
+export function stableSortByPath(items: string[]): string[] {
+  return stableSortInPlace([...items], comparePaths);
+}