@usefragments/core 1.0.0

package/src/__tests__/preview-runtime.test.tsx

@@ -0,0 +1,111 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  executeVariantLoaders,
+  resolvePreviewRuntimeState,
+  type PreviewVariantLike,
+} from "../preview-runtime.js";
+
+describe("executeVariantLoaders", () => {
+  it("returns host loadedData when no loaders are defined", async () => {
+    const loadedData = { source: "host", count: 1 };
+    const result = await executeVariantLoaders(undefined, loadedData);
+    expect(result).toEqual(loadedData);
+  });
+
+  it("merges loader results and applies host loadedData last", async () => {
+    const result = await executeVariantLoaders(
+      [
+        async () => ({ count: 1, fromFirst: true }),
+        async () => ({ count: 2, fromSecond: true }),
+      ],
+      { count: 3, fromHost: true },
+    );
+
+    expect(result).toEqual({
+      count: 3,
+      fromFirst: true,
+      fromSecond: true,
+      fromHost: true,
+    });
+  });
+});
+
+describe("resolvePreviewRuntimeState", () => {
+  it("renders variants with no loaders", async () => {
+    const variant: PreviewVariantLike = {
+      render: () => "Preview content",
+    };
+
+    const state = await resolvePreviewRuntimeState({ variant });
+
+    expect(state.isLoading).toBe(false);
+    expect(state.error).toBeNull();
+    expect(state.content).toBe("Preview content");
+  });
+
+  it("renders with successful loaders", async () => {
+    const variant: PreviewVariantLike = {
+      loaders: [async () => ({ label: "from-loader" })],
+      render: (options) => `Loaded: ${String(options?.loadedData?.label)}`,
+    };
+
+    const state = await resolvePreviewRuntimeState({ variant });
+
+    expect(state.error).toBeNull();
+    expect(state.loadedData).toEqual({ label: "from-loader" });
+    expect(state.content).toBe("Loaded: from-loader");
+  });
+
+  it("returns an error when a loader rejects", async () => {
+    const variant: PreviewVariantLike = {
+      loaders: [async () => { throw new Error("loader failed"); }],
+      render: () => "should not render",
+    };
+
+    const state = await resolvePreviewRuntimeState({ variant });
+
+    expect(state.content).toBeNull();
+    expect(state.error?.message).toContain("loader failed");
+  });
+
+  it("returns an error when render throws", async () => {
+    const variant: PreviewVariantLike = {
+      render: () => {
+        throw new Error("render failed");
+      },
+    };
+
+    const state = await resolvePreviewRuntimeState({ variant });
+
+    expect(state.content).toBeNull();
+    expect(state.error?.message).toContain("render failed");
+  });
+
+  it("normalizes non-Error throwables", async () => {
+    const variant: PreviewVariantLike = {
+      loaders: [async () => { throw "string-failure"; }],
+      render: () => "never",
+    };
+
+    const state = await resolvePreviewRuntimeState({ variant });
+    expect(state.error).not.toBeNull();
+    expect(state.error?.message).toContain("string-failure");
+  });
+
+  it("uses host data as override input in render options", async () => {
+    const renderSpy = vi.fn((options?: { loadedData?: Record<string, unknown> }) => options?.loadedData);
+    const variant: PreviewVariantLike = {
+      loaders: [async () => ({ count: 1 })],
+      render: renderSpy,
+    };
+
+    const state = await resolvePreviewRuntimeState({
+      variant,
+      loadedData: { count: 2, source: "host" },
+    });
+
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(state.loadedData).toEqual({ count: 2, source: "host" });
+    expect(state.content).toEqual({ count: 2, source: "host" });
+  });
+});

package/src/__tests__/schema.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+
+import { observedUsagePropSchema } from '../schema.js';
+
+describe('observedUsagePropSchema', () => {
+  it('accepts structural JSX children observations', () => {
+    expect(
+      observedUsagePropSchema.safeParse({
+        name: 'children',
+        kind: 'jsx',
+      }).success,
+    ).toBe(true);
+  });
+
+  it('accepts boolean and null prop observations', () => {
+    expect(
+      observedUsagePropSchema.safeParse({
+        name: 'disabled',
+        kind: 'boolean',
+        value: true,
+      }).success,
+    ).toBe(true);
+    expect(
+      observedUsagePropSchema.safeParse({
+        name: 'tone',
+        kind: 'null',
+        value: null,
+      }).success,
+    ).toBe(true);
+  });
+});

package/src/__tests__/severity.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  SEVERITIES,
+  compareSeverity,
+  maxSeverity,
+  severityLevel,
+  severitySchema,
+  sortBySeverity,
+} from "../severity.js";
+
+describe("severity helpers", () => {
+  it("keeps the canonical four-level vocabulary", () => {
+    expect(SEVERITIES).toEqual(["critical", "serious", "moderate", "minor"]);
+    expect(severitySchema.safeParse("warning").success).toBe(false);
+  });
+
+  it("derives two-level CI/editor level from severity", () => {
+    expect(severityLevel("critical")).toBe("error");
+    expect(severityLevel("serious")).toBe("error");
+    expect(severityLevel("moderate")).toBe("warn");
+    expect(severityLevel("minor")).toBe("warn");
+  });
+
+  it("compares and sorts from most severe to least severe", () => {
+    expect(compareSeverity("critical", "minor")).toBeLessThan(0);
+    expect(maxSeverity("moderate", "serious")).toBe("serious");
+    expect(sortBySeverity(["minor", "critical", "moderate"], (item) => item)).toEqual([
+      "critical",
+      "moderate",
+      "minor",
+    ]);
+  });
+});