@sanity/workbench 0.1.0-alpha.7 → 0.1.0-alpha.9

package/src/core/shared/urls.test.ts

@@ -1,182 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { createPath, joinUrlPaths, normalizePath, parsePath } from "./urls";
-
-describe("joinUrlPaths", () => {
-  it("joins two simple segments", () => {
-    expect(joinUrlPaths("foo", "bar")).toBe("foo/bar");
-  });
-
-  it("handles trailing slash on first segment", () => {
-    expect(joinUrlPaths("foo/", "bar")).toBe("foo/bar");
-  });
-
-  it("handles leading slash on second segment", () => {
-    expect(joinUrlPaths("foo", "/bar")).toBe("foo/bar");
-  });
-
-  it("collapses double slashes at the join", () => {
-    expect(joinUrlPaths("foo/", "/bar")).toBe("foo/bar");
-  });
-
-  it("joins multiple segments", () => {
-    expect(joinUrlPaths("a", "b", "c")).toBe("a/b/c");
-  });
-
-  it("skips null and undefined values", () => {
-    expect(joinUrlPaths("a", null, undefined, "b")).toBe("a/b");
-  });
-
-  it("returns empty string for all nullish inputs", () => {
-    expect(joinUrlPaths(null, undefined)).toBe("");
-  });
-
-  it("returns empty string with no arguments", () => {
-    expect(joinUrlPaths()).toBe("");
-  });
-
-  it("returns single segment unchanged", () => {
-    expect(joinUrlPaths("foo")).toBe("foo");
-  });
-
-  it("extracts pathname from URL objects", () => {
-    const url = new URL("https://example.com/api");
-    expect(joinUrlPaths(url, "users")).toBe("/api/users");
-  });
-
-  it("handles URL object with trailing slash", () => {
-    const url = new URL("https://example.com/api/");
-    expect(joinUrlPaths(url, "users")).toBe("/api/users");
-  });
-
-  it("joins two URL objects", () => {
-    const a = new URL("https://example.com/api");
-    const b = new URL("https://example.com/v2");
-    expect(joinUrlPaths(a, b)).toBe("/api/v2");
-  });
-});
-
-describe("normalizePath", () => {
-  it("adds leading slash when missing", () => {
-    expect(normalizePath("foo")).toBe("/foo");
-  });
-
-  it("preserves existing leading slash", () => {
-    expect(normalizePath("/foo")).toBe("/foo");
-  });
-
-  it("removes trailing slash", () => {
-    expect(normalizePath("/foo/")).toBe("/foo");
-  });
-
-  it("preserves root path", () => {
-    expect(normalizePath("/")).toBe("/");
-  });
-
-  it("handles bare segment with trailing slash", () => {
-    expect(normalizePath("foo/")).toBe("/foo");
-  });
-
-  it("handles deeper paths", () => {
-    expect(normalizePath("/a/b/c/")).toBe("/a/b/c");
-  });
-});
-
-describe("parsePath", () => {
-  it("parses pathname only", () => {
-    expect(parsePath("/foo")).toEqual({ pathname: "/foo" });
-  });
-
-  it("parses pathname with search", () => {
-    expect(parsePath("/foo?bar=1")).toEqual({
-      pathname: "/foo",
-      search: "?bar=1",
-    });
-  });
-
-  it("parses pathname with hash", () => {
-    expect(parsePath("/foo#heading")).toEqual({
-      pathname: "/foo",
-      hash: "#heading",
-    });
-  });
-
-  it("parses pathname with search and hash", () => {
-    expect(parsePath("/foo?bar=1#heading")).toEqual({
-      pathname: "/foo",
-      search: "?bar=1",
-      hash: "#heading",
-    });
-  });
-
-  it("parses hash that appears before search in the string", () => {
-    expect(parsePath("/foo#heading?notSearch")).toEqual({
-      pathname: "/foo",
-      hash: "#heading?notSearch",
-    });
-  });
-
-  it("returns empty object for empty string", () => {
-    expect(parsePath("")).toEqual({});
-  });
-
-  it("parses search-only path", () => {
-    expect(parsePath("?q=1")).toEqual({ search: "?q=1" });
-  });
-
-  it("parses hash-only path", () => {
-    expect(parsePath("#top")).toEqual({ hash: "#top" });
-  });
-});
-
-describe("createPath", () => {
-  it("returns pathname only", () => {
-    expect(createPath({ pathname: "/foo" })).toBe("/foo");
-  });
-
-  it("appends search string", () => {
-    expect(createPath({ pathname: "/foo", search: "?bar=1" })).toBe(
-      "/foo?bar=1",
-    );
-  });
-
-  it("appends hash string", () => {
-    expect(createPath({ pathname: "/foo", hash: "#heading" })).toBe(
-      "/foo#heading",
-    );
-  });
-
-  it("appends both search and hash", () => {
-    expect(
-      createPath({
-        pathname: "/foo",
-        search: "?bar=1",
-        hash: "#heading",
-      }),
-    ).toBe("/foo?bar=1#heading");
-  });
-
-  it("adds ? prefix when search is missing it", () => {
-    expect(createPath({ pathname: "/foo", search: "bar=1" })).toBe(
-      "/foo?bar=1",
-    );
-  });
-
-  it("adds # prefix when hash is missing it", () => {
-    expect(createPath({ pathname: "/foo", hash: "heading" })).toBe(
-      "/foo#heading",
-    );
-  });
-
-  it("defaults pathname to /", () => {
-    expect(createPath({})).toBe("/");
-  });
-
-  it("ignores bare ? search", () => {
-    expect(createPath({ pathname: "/foo", search: "?" })).toBe("/foo");
-  });
-
-  it("ignores bare # hash", () => {
-    expect(createPath({ pathname: "/foo", hash: "#" })).toBe("/foo");
-  });
-});

package/src/core/user-applications/core-app.test.ts

@@ -1,151 +0,0 @@
-import type { ApplicationResource as ProtocolApplicationResource } from "@sanity/message-protocol";
-import { afterEach, describe, expect, expectTypeOf, it, vi } from "vitest";
-
-import { APPLICATION_DATA } from "../__tests__/__fixtures__";
-import { CoreAppApplication } from "./core-app";
-
-const setup = () => new CoreAppApplication(APPLICATION_DATA);
-
-describe("CoreAppApplication", () => {
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-  it("should have a type of coreApp", () => {
-    const application = setup();
-    expect(application.type).toBe("coreApp");
-  });
-
-  it("should have a href of <application>/<id>", () => {
-    const application = setup();
-    expect(application.href).toBe("/application/v27rvqtlp3lmdvcln6ey3lro");
-  });
-
-  it("should have a name of the application title", () => {
-    const application = setup();
-    expect(application.title).toBe("sdk-movie-list");
-  });
-
-  it("should have a updatedAt property", () => {
-    const application = setup();
-    expect(application.updatedAt).toBe("2025-03-27T19:00:32.792Z");
-  });
-
-  it("should have an activeDeployment property", () => {
-    const application = setup();
-    expect(application.activeDeployment).toMatchInlineSnapshot(`
-      {
-        "createdAt": "2025-03-27T19:07:21.038Z",
-        "deployedAt": "2025-03-27T19:07:21.082Z",
-        "deployedBy": "gwXueEBci",
-        "id": "dv3kz3fsl4aqha3parc8k391",
-        "isActiveDeployment": true,
-        "isAutoUpdating": false,
-        "manifest": null,
-        "size": 528292,
-        "updatedAt": "2025-03-27T19:07:21.082Z",
-        "userApplicationId": "v27rvqtlp3lmdvcln6ey3lro",
-        "version": "3.81.0",
-      }
-    `);
-  });
-
-  it("should implement the toProtocolResource method", () => {
-    vi.stubEnv("VITE_SANITY_ENV", "staging");
-    vi.stubEnv("VITE_SANITY_DOMAIN", "sanity.work");
-    const application = setup();
-    expect(application.toProtocolResource()).toMatchInlineSnapshot(`
-      {
-        "activeDeployment": {
-          "createdAt": "2025-03-27T19:07:21.038Z",
-          "deployedAt": "2025-03-27T19:07:21.082Z",
-          "deployedBy": "gwXueEBci",
-          "id": "dv3kz3fsl4aqha3parc8k391",
-          "isActiveDeployment": true,
-          "isAutoUpdating": false,
-          "manifest": null,
-          "size": 528292,
-          "updatedAt": "2025-03-27T19:07:21.082Z",
-          "userApplicationId": "v27rvqtlp3lmdvcln6ey3lro",
-          "version": "3.81.0",
-        },
-        "appHost": "x7apsmr6fxvc",
-        "createdAt": "2025-03-27T19:00:32.792Z",
-        "dashboardStatus": "default",
-        "id": "v27rvqtlp3lmdvcln6ey3lro",
-        "organizationId": "oSyH1iET5",
-        "projectId": null,
-        "title": "sdk-movie-list",
-        "type": "application",
-        "updatedAt": "2025-03-27T19:00:32.792Z",
-        "url": "https://x7apsmr6fxvc.studio.sanity.work/",
-        "urlType": "internal",
-      }
-    `);
-
-    expectTypeOf(
-      application.toProtocolResource(),
-    ).toEqualTypeOf<ProtocolApplicationResource>();
-  });
-
-  it("should return undefined for subtitle", () => {
-    const application = setup();
-    expect(application.subtitle).toBeUndefined();
-  });
-
-  describe("get", () => {
-    it("should throw when accessing a non-existent attribute", () => {
-      const application = setup();
-      expect(() =>
-        // @ts-expect-error - testing invalid attribute
-        application.get("nonExistent"),
-      ).toThrow(
-        "Attribute nonExistent does not exist on application v27rvqtlp3lmdvcln6ey3lro",
-      );
-    });
-  });
-
-  describe("manifest functionality", () => {
-    it("should use manifest from application when present", () => {
-      const applicationWithManifest = {
-        ...APPLICATION_DATA,
-        activeDeployment: {
-          ...APPLICATION_DATA.activeDeployment,
-          manifest: {
-            version: "1.0.0",
-            icon: "<svg>test-icon</svg>",
-            title: "Manifest Title",
-          },
-        },
-      };
-      const application = new CoreAppApplication(applicationWithManifest);
-      expect(application.title).toBe("Manifest Title");
-    });
-
-    it("should use manifest from activeDeployment when application manifest is not present", () => {
-      const applicationWithDeploymentManifest = {
-        ...APPLICATION_DATA,
-        activeDeployment: {
-          ...APPLICATION_DATA.activeDeployment,
-          manifest: {
-            version: "1.0.0",
-            icon: "<svg>deployment-icon</svg>",
-            title: "Deployment Title",
-          },
-        },
-      };
-      const application = new CoreAppApplication(
-        applicationWithDeploymentManifest,
-      );
-      expect(application.title).toBe("Deployment Title");
-    });
-
-    it("should allow you to get attributes from the application", () => {
-      const application = setup();
-
-      expect(application.get("title")).toBe("sdk-movie-list");
-      expect(application.get("urlType")).toBe("internal");
-      expect(application.get("appHost")).toBe("x7apsmr6fxvc");
-      expectTypeOf(application.get("appHost")).toEqualTypeOf<string>();
-    });
-  });
-});