@inglorious/web 3.0.0 → 3.0.1

package/src/list/list.test.js

@@ -1,228 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-import { html } from "lit-html"
-import { beforeEach, describe, expect, it, vi } from "vitest"
-
-import { list } from "."
-
-describe("list", () => {
-  let entity
-
-  beforeEach(() => {
-    entity = {
-      id: "test-list",
-      type: "test-item-type",
-      items: Array.from({ length: 100 }, (_, i) => ({
-        id: i,
-        name: `Item ${i}`,
-      })),
-    }
-  })
-
-  describe("and create()", () => {
-    it("should set default list properties on init", () => {
-      list.create(entity)
-      expect(entity.scrollTop).toBe(0)
-      expect(entity.visibleRange).toEqual({ start: 0, end: 20 })
-      expect(entity.viewportHeight).toBe(600)
-      expect(entity.bufferSize).toBe(5)
-      expect(entity.itemHeight).toBeNull()
-      expect(entity.estimatedHeight).toBe(50)
-    })
-
-    it("should not overwrite existing properties on init (except scrollTop)", () => {
-      entity.viewportHeight = 800
-      entity.visibleRange = { start: 10, end: 30 }
-
-      list.create(entity)
-
-      expect(entity.viewportHeight).toBe(800)
-      expect(entity.visibleRange).toEqual({ start: 10, end: 30 })
-      expect(entity.scrollTop).toBe(0) // scrollTop is always reset
-    })
-
-    it("should reset the list on create", () => {
-      list.create(entity)
-      expect(entity.scrollTop).toBe(0)
-      expect(entity.visibleRange).toEqual({ start: 0, end: 20 })
-    })
-  })
-
-  describe("scroll()", () => {
-    beforeEach(() => {
-      list.create(entity)
-    })
-
-    it("should calculate visible range based on itemHeight", () => {
-      entity.itemHeight = 20
-      const containerEl = { scrollTop: 200 } // 10 items down
-
-      list.scroll(entity, containerEl)
-
-      // start = floor(200 / 20) - 5 = 10 - 5 = 5
-      // visibleCount = ceil(600 / 20) = 30
-      // end = min(5 + 30 + 5, 100) = 40
-      expect(entity.visibleRange).toEqual({ start: 5, end: 40 })
-      expect(entity.scrollTop).toBe(200)
-    })
-
-    it("should calculate visible range based on estimatedHeight if itemHeight is null", () => {
-      entity.estimatedHeight = 50
-      const containerEl = { scrollTop: 500 } // 10 items down
-
-      list.scroll(entity, containerEl)
-
-      // start = floor(500 / 50) - 5 = 10 - 5 = 5
-      // visibleCount = ceil(600 / 50) = 12
-      // end = min(5 + 12 + 5, 100) = 22
-      expect(entity.visibleRange).toEqual({ start: 5, end: 22 })
-    })
-
-    it("should not update if the visible range has not changed", () => {
-      entity.itemHeight = 20
-      entity.visibleRange = { start: 5, end: 40 }
-      const originalRange = { ...entity.visibleRange }
-
-      const containerEl = { scrollTop: 201 } // Still within the same range calculation
-      list.scroll(entity, containerEl)
-
-      expect(entity.visibleRange).toEqual(originalRange) // Should not have changed
-    })
-
-    it("should handle scrolling to the top", () => {
-      entity.itemHeight = 20
-      const containerEl = { scrollTop: 0 }
-
-      list.scroll(entity, containerEl)
-
-      // start = max(0, floor(0/20) - 5) = 0
-      // end = min(0 + 30 + 5, 100) = 35
-      expect(entity.visibleRange).toEqual({ start: 0, end: 35 })
-    })
-
-    it("should handle scrolling near the bottom", () => {
-      entity.itemHeight = 20
-      const containerEl = { scrollTop: 1900 } // 95 items down
-
-      list.scroll(entity, containerEl)
-
-      // start = floor(1900 / 20) - 5 = 95 - 5 = 90
-      // visibleCount = 30
-      // end = min(90 + 30 + 5, 100) = 100
-      expect(entity.visibleRange).toEqual({ start: 90, end: 100 })
-    })
-  })
-
-  describe("mount()", () => {
-    it("should measure and set itemHeight and update visibleRange", () => {
-      list.create(entity)
-      const itemEl = document.createElement("div")
-      vi.spyOn(itemEl, "offsetHeight", "get").mockReturnValue(40)
-
-      const containerEl = {
-        querySelector: vi.fn().mockReturnValue(itemEl),
-      }
-
-      list.mount(entity, containerEl)
-
-      expect(containerEl.querySelector).toHaveBeenCalledWith("[data-index]")
-      expect(entity.itemHeight).toBe(40)
-      // end = ceil(600 / 40) = 15
-      expect(entity.visibleRange).toEqual({ start: 0, end: 15 })
-    })
-
-    it("should do nothing if no item element is found", () => {
-      list.create(entity)
-      const originalEntity = { ...entity }
-      const containerEl = {
-        querySelector: vi.fn().mockReturnValue(null),
-      }
-
-      list.mount(entity, containerEl)
-
-      expect(entity).toEqual(originalEntity)
-    })
-  })
-
-  describe("render()", () => {
-    let api
-
-    beforeEach(() => {
-      list.create(entity)
-      api = {
-        notify: vi.fn(),
-        getType: vi.fn().mockReturnValue({
-          renderItem: (item, index) => html`<div>${index}: ${item.name}</div>`,
-        }),
-      }
-    })
-
-    it("should return a lit-html TemplateResult", () => {
-      const result = list.render(entity, api)
-      // Duck-typing for TemplateResult, as it's not a public class
-      expect(result).toHaveProperty("strings")
-      expect(result).toHaveProperty("values")
-    })
-
-    it("should warn and return empty if items are missing", () => {
-      const spy = vi.spyOn(console, "warn").mockImplementation(() => {})
-      delete entity.items
-      const result = list.render(entity, api)
-      expect(spy).toHaveBeenCalledWith(`list entity ${entity.id} needs 'items'`)
-      expect(result.strings.join("").trim()).toBe("")
-      spy.mockRestore()
-    })
-
-    it("should warn and return empty if type.renderItem is missing", () => {
-      const spy = vi.spyOn(console, "warn").mockImplementation(() => {})
-      api.getType.mockReturnValue({}) // No renderItem
-      const result = list.render(entity, api)
-      expect(spy).toHaveBeenCalledWith(
-        `type ${entity.type} needs 'renderItem' method`,
-      )
-      expect(result.strings.join("").trim()).toBe("")
-      spy.mockRestore()
-    })
-
-    it("should render only the visible items", () => {
-      entity.itemHeight = 50
-      entity.visibleRange = { start: 10, end: 15 } // 5 visible items
-
-      const result = list.render(entity, api)
-      const renderedItems = result.values.find(Array.isArray)
-
-      expect(renderedItems).toHaveLength(5) // 5 visible items
-      // Check if the first rendered item is indeed item 10
-      const innerTemplate = renderedItems[0].values[2]
-      const renderedText = `${innerTemplate.values[0]}: ${innerTemplate.values[1]}`
-      expect(renderedText).toBe("10: Item 10")
-    })
-
-    it("should calculate total height correctly", () => {
-      entity.itemHeight = 40
-      const result = list.render(entity, api)
-      // The styleMap for the inner div is at result.values[3].values[0]
-      const styleValue = result.values[3].values[0]
-      const expectedHeight = 100 * 40 // items.length * itemHeight
-      expect(styleValue.height).toBe(`${expectedHeight}px`)
-    })
-  })
-
-  describe("renderItem()", () => {
-    it("should render a default item view", () => {
-      const item = { id: 1, value: "test" }
-      const result = list.renderItem(item, 5)
-      // Duck-typing for TemplateResult
-      expect(result).toHaveProperty("strings")
-      expect(result).toHaveProperty("values")
-      const fullText =
-        result.strings[0] +
-        result.values[0] +
-        result.strings[1] +
-        result.values[1] +
-        result.strings[2]
-      expect(fullText).toBe(`<div>6. ${JSON.stringify(item)}</div>`)
-    })
-  })
-})

package/src/router/router.test.js

@@ -1,208 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-
-import { router } from "."
-
-describe("router", () => {
-  let entity
-  let api
-
-  beforeEach(() => {
-    entity = {
-      id: "router",
-      type: "router",
-      routes: {
-        "/": "homePage",
-        "/users": "userListPage",
-        "/users/:id": "userPage",
-        "/users/:id/posts/:postId": "postPage",
-        "*": "notFoundPage",
-      },
-    }
-
-    api = {
-      getEntity: vi.fn().mockReturnValue(entity),
-      notify: vi.fn(),
-    }
-
-    // Mock window.location and history
-    vi.spyOn(window, "location", "get").mockReturnValue({
-      pathname: "/",
-      search: "",
-      hash: "",
-      origin: "http://localhost:3000",
-    })
-    vi.spyOn(history, "pushState").mockImplementation(() => {})
-    vi.spyOn(history, "replaceState").mockImplementation(() => {})
-    vi.spyOn(history, "go").mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  describe("init()", () => {
-    it("should initialize with the current window.location, set up a popstate listener, and set up a click listener for link interception", () => {
-      vi.spyOn(window, "location", "get").mockReturnValue({
-        pathname: "/users/123",
-        search: "?sort=asc",
-        hash: "#details",
-        origin: "http://localhost:3000",
-      })
-      const windowSpy = vi.spyOn(window, "addEventListener")
-      const documentSpy = vi.spyOn(document, "addEventListener")
-
-      router.init(entity, undefined, api)
-
-      expect(api.notify).toHaveBeenCalledWith("#router:navigate", {
-        to: "/users/123?sort=asc",
-        params: { id: "123" },
-        replace: true,
-      })
-      expect(windowSpy).toHaveBeenCalledWith("popstate", expect.any(Function))
-      expect(documentSpy).toHaveBeenCalledWith("click", expect.any(Function))
-    })
-  })
-
-  describe("navigate()", () => {
-    it("should navigate to a new path and update the entity", () => {
-      router.navigate(entity, "/users/456?q=test", api)
-
-      expect(entity.path).toBe("/users/456")
-      expect(entity.route).toBe("userPage")
-      expect(entity.params).toEqual({ id: "456" })
-      expect(entity.query).toEqual({ q: "test" })
-      expect(history.pushState).toHaveBeenCalledWith(
-        expect.any(Object),
-        "",
-        "/users/456?q=test",
-      )
-      expect(api.notify).toHaveBeenCalledWith("routeChange", expect.any(Object))
-    })
-
-    it("should use replaceState when replace is true", () => {
-      router.navigate(entity, { to: "/users", replace: true }, api)
-      expect(history.replaceState).toHaveBeenCalled()
-      expect(history.pushState).not.toHaveBeenCalled()
-    })
-
-    it("should handle numeric navigation", () => {
-      router.navigate(entity, -1, api)
-      expect(history.go).toHaveBeenCalledWith(-1)
-    })
-
-    it("should build path from params", () => {
-      router.navigate(
-        entity,
-        { to: "/users/:id/posts/:postId", params: { id: 1, postId: 2 } },
-        api,
-      )
-      expect(history.pushState).toHaveBeenCalledWith(
-        expect.any(Object),
-        "",
-        "/users/1/posts/2",
-      )
-      expect(entity.route).toBe("postPage")
-      expect(entity.params).toEqual({ id: "1", postId: "2" })
-    })
-
-    it("should use the fallback route for unknown paths", () => {
-      router.navigate(entity, "/some/unknown/path", api)
-      expect(entity.route).toBe("notFoundPage")
-      expect(entity.params).toEqual({})
-    })
-
-    it("should not navigate if the path is identical", () => {
-      entity.path = "/users"
-      vi.spyOn(window, "location", "get").mockReturnValue({
-        pathname: "/users",
-        search: "",
-        hash: "",
-      })
-
-      router.navigate(entity, "/users", api)
-
-      expect(history.pushState).not.toHaveBeenCalled()
-      expect(api.notify).not.toHaveBeenCalledWith(
-        "routeChange",
-        expect.any(Object),
-      )
-    })
-
-    it("should navigate if the path is identical but force is true", () => {
-      entity.path = "/users"
-      vi.spyOn(window, "location", "get").mockReturnValue({
-        pathname: "/users",
-        search: "",
-        hash: "",
-      })
-
-      router.navigate(entity, { to: "/users", force: true }, api)
-
-      expect(history.pushState).toHaveBeenCalled()
-      expect(api.notify).toHaveBeenCalledWith("routeChange", expect.any(Object))
-    })
-  })
-
-  describe("routeSync()", () => {
-    it("should update the entity state from a payload", () => {
-      const payload = {
-        path: "/new?a=1",
-        entityType: "newPage",
-        params: {},
-      }
-
-      vi.spyOn(window, "location", "get").mockReturnValue({ hash: "#section" })
-
-      router.routeSync(entity, payload)
-
-      expect(entity.path).toBe("/new")
-      expect(entity.route).toBe("newPage")
-      expect(entity.query).toEqual({ a: "1" })
-      expect(entity.hash).toBe("#section")
-    })
-  })
-
-  describe("loadSuccess()", () => {
-    it("should handle lazy loaded modules", () => {
-      const module = { myPage: { render: () => {} } }
-      const route = { pattern: "/lazy", params: {} }
-      const payload = {
-        module,
-        route,
-        path: "/lazy",
-        replace: false,
-        state: {},
-      }
-
-      router.loadSuccess(entity, payload, api)
-
-      expect(api.notify).toHaveBeenCalledWith("morph", {
-        name: "myPage",
-        type: module.myPage,
-      })
-      expect(entity.routes["/lazy"]).toBe("myPage")
-      expect(entity.loading).toBe(false)
-      expect(entity.route).toBe("myPage")
-      expect(history.pushState).toHaveBeenCalled()
-    })
-  })
-
-  describe("loadError()", () => {
-    it("should handle load errors", () => {
-      const error = new Error("Failed")
-      const payload = { error, path: "/lazy" }
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {})
-
-      router.loadError(entity, payload)
-
-      expect(entity.path).toBe("/lazy")
-      expect(entity.loading).toBe(false)
-      expect(entity.error).toBe(error)
-
-      consoleSpy.mockRestore()
-    })
-  })
-})