@inglorious/web 2.2.0 → 2.2.2

package/src/mount.js

@@ -9,40 +9,24 @@ import { html, render } from "lit-html"
  */
 export function mount(store, renderFn, element) {
   const api = { ...store._api }
-  api.select = createReactiveSelector(api, store)
   api.render = createRender(api)
 
-  const unsubscribe = store.subscribe(() => render(renderFn(api), element))
-  store.notify("init")
-
-  return unsubscribe
-}
-
-/**
- * Creates a reactive selector function for the mount API.
- * @param {import('../types/mount').Api} api - The mount API.
- * @param {import('@inglorious/store').Store} store - The application state store.
- * @returns {import('../types/mount').Api['select']} A `select` function that can be used to get a reactive slice of the state.
- * @private
- */
-function createReactiveSelector(api, store) {
-  return function select(selectorFn) {
-    let current = selectorFn(api)
-
-    const unsubscribe = store.subscribe(() => {
-      const next = selectorFn(api)
-      if (next !== current) {
-        current = next
-      }
-    })
+  let renderScheduled = false
 
-    return {
-      get value() {
-        return current
-      },
-      unsubscribe,
+  const scheduleRender = () => {
+    if (!renderScheduled) {
+      renderScheduled = true
+      requestAnimationFrame(() => {
+        renderScheduled = false
+        render(renderFn(api), element)
+      })
     }
   }
+
+  const unsubscribe = store.subscribe(scheduleRender)
+  store.notify("init")
+
+  return unsubscribe
 }
 
 /**

package/src/router.test.js

@@ -0,0 +1,158 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import { router } from "./router.js"
+
+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", () => {
+      vi.spyOn(window, "location", "get").mockReturnValue({
+        pathname: "/users/123",
+        search: "?sort=asc",
+        hash: "#details",
+        origin: "http://localhost:3000",
+      })
+
+      router.init(entity, {}, api)
+
+      expect(entity.path).toBe("/users/123")
+      expect(entity.route).toBe("userPage")
+      expect(entity.params).toEqual({ id: "123" })
+      expect(entity.query).toEqual({ sort: "asc" })
+      expect(entity.hash).toBe("#details")
+    })
+
+    it("should set up a popstate listener", () => {
+      const spy = vi.spyOn(window, "addEventListener")
+      router.init(entity, {}, api)
+      expect(spy).toHaveBeenCalledWith("popstate", expect.any(Function))
+    })
+
+    it("should set up a click listener for link interception", () => {
+      const spy = vi.spyOn(document, "addEventListener")
+      router.init(entity, {}, api)
+      expect(spy).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),
+      )
+    })
+  })
+
+  describe("routeSync()", () => {
+    it("should update the entity state from a payload", () => {
+      const payload = {
+        path: "/new",
+        entityType: "newPage",
+        params: {},
+        query: { a: "1" },
+        hash: "#section",
+      }
+      router.routeSync(entity, payload)
+      expect(entity.path).toBe("/new")
+      expect(entity.route).toBe("newPage")
+      expect(entity.query).toEqual({ a: "1" })
+    })
+  })
+})

package/src/table/rendering.js

@@ -100,14 +100,13 @@ export const rendering = {
 
     return html`<div
       @click=${() => api.notify(`#${entity.id}:rowToggle`, rowId)}
-      class=${classMap({
-        "iw-table-row": true,
+      class="iw-table-row ${classMap({
         "iw-table-row-even": index % DIVISOR,
-        "iw-table-row-selected": entity.selection.includes(rowId),
-      })}
+        "iw-table-row-selected": entity.selection?.includes(rowId),
+      })}"
     >
-      ${Object.values(row).map((value, index) =>
-        type.renderCell(entity, value, index, api),
+      ${entity.columns.map((column, index) =>
+        type.renderCell(entity, row[column.id], index, api),
       )}
     </div>`
   },
@@ -117,12 +116,11 @@ export const rendering = {
     const column = entity.columns[index]
 
     return html`<div
-      class=${classMap({
-        "iw-table-cell": true,
+      class="iw-table-cell ${classMap({
         "iw-table-cell-number": column.type === "number",
         "iw-table-cell-date": column.type === "date",
         "iw-table-cell-boolean": column.type === "boolean",
-      })}
+      })}"
       style=${getColumnStyle(column)}
     >
       ${type.renderValue(cell, column, api)}

package/src/table.test.js

@@ -0,0 +1,372 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { html } from "lit-html"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+// Mock the filters module to prevent devtools-related errors in the test environment.
+vi.mock("./table/filters.js", () => ({
+  filters: { render: () => html`` },
+}))
+
+import { table } from "./table.js"
+import {
+  getPaginationInfo,
+  getRows,
+  getSortDirection,
+  getTotalRows,
+  isAllSelected,
+  isSomeSelected,
+} from "./table/logic.js"
+
+const sampleData = [
+  { id: 1, name: "Charlie", age: 35, active: true, role: "Admin" },
+  { id: 2, name: "Alice", age: 30, active: true, role: "User" },
+  { id: 3, name: "Bob", age: 25, active: false, role: "User" },
+  { id: 4, name: "David", age: 40, active: true, role: "Admin" },
+]
+
+const sampleColumns = [
+  { id: "name", title: "Name", isSortable: true, isFilterable: true },
+  {
+    id: "age",
+    title: "Age",
+    type: "number",
+    isSortable: true,
+    isFilterable: true,
+  },
+  {
+    id: "active",
+    title: "Active",
+    type: "boolean",
+    isFilterable: true,
+  },
+  {
+    id: "role",
+    title: "Role",
+    isFilterable: true,
+    filter: { type: "select", options: ["Admin", "User"] },
+  },
+]
+
+describe("table", () => {
+  let entity
+
+  beforeEach(() => {
+    entity = {
+      id: "test-table",
+      type: "table",
+      data: JSON.parse(JSON.stringify(sampleData)), // Deep clone
+      columns: JSON.parse(JSON.stringify(sampleColumns)),
+      pagination: { page: 0, pageSize: 2 },
+      search: { value: "" },
+    }
+    table.init(entity)
+  })
+
+  describe("logic", () => {
+    describe("init() and create()", () => {
+      it("should initialize with default state", () => {
+        const newEntity = { data: [{ id: 1, name: "Test" }] }
+        table.init(newEntity)
+        expect(newEntity.sorts).toEqual([])
+        expect(newEntity.filters).toEqual({})
+        expect(newEntity.selection).toEqual([])
+        expect(newEntity.columns).toBeDefined()
+        expect(newEntity.columns[0].id).toBe("id")
+        expect(newEntity.columns[0].title).toBe("Id")
+      })
+    })
+
+    describe("sortChange()", () => {
+      it("should add a new sort", () => {
+        table.sortChange(entity, "name")
+        expect(entity.sorts).toEqual([{ column: "name", direction: "asc" }])
+      })
+
+      it("should toggle sort direction from asc to desc", () => {
+        table.sortChange(entity, "name") // asc
+        table.sortChange(entity, "name") // desc
+        expect(entity.sorts).toEqual([{ column: "name", direction: "desc" }])
+      })
+
+      it("should remove sort when toggling from desc", () => {
+        table.sortChange(entity, "name") // asc
+        table.sortChange(entity, "name") // desc
+        table.sortChange(entity, "name") // remove
+        expect(entity.sorts).toEqual([])
+      })
+
+      it("should reset to page 0 on sort change", () => {
+        entity.pagination.page = 1
+        table.sortChange(entity, "name")
+        expect(entity.pagination.page).toBe(0)
+      })
+    })
+
+    describe("filterChange()", () => {
+      it("should add a filter", () => {
+        table.filterChange(entity, { columnId: "name", value: "Alice" })
+        expect(entity.filters.name).toBe("Alice")
+      })
+
+      it("should remove a filter when value is empty", () => {
+        table.filterChange(entity, { columnId: "name", value: "Alice" })
+        table.filterChange(entity, { columnId: "name", value: "" })
+        expect(entity.filters.name).toBeUndefined()
+      })
+
+      it("should reset to page 0 on filter change", () => {
+        entity.pagination.page = 1
+        table.filterChange(entity, { columnId: "name", value: "Alice" })
+        expect(entity.pagination.page).toBe(0)
+      })
+    })
+
+    describe("pagination", () => {
+      it("pageNext: should go to the next page", () => {
+        table.pageNext(entity)
+        expect(entity.pagination.page).toBe(1)
+      })
+
+      it("pageNext: should not go past the last page", () => {
+        table.pageNext(entity) // page 1
+        table.pageNext(entity) // still page 1 (total 4 items, size 2 -> 2 pages)
+        expect(entity.pagination.page).toBe(1)
+      })
+
+      it("pagePrev: should go to the previous page", () => {
+        entity.pagination.page = 1
+        table.pagePrev(entity)
+        expect(entity.pagination.page).toBe(0)
+      })
+
+      it("pagePrev: should not go before the first page", () => {
+        table.pagePrev(entity)
+        expect(entity.pagination.page).toBe(0)
+      })
+
+      it("pageSizeChange: should change page size and reset to page 0", () => {
+        entity.pagination.page = 1
+        table.pageSizeChange(entity, 4)
+        expect(entity.pagination.pageSize).toBe(4)
+        expect(entity.pagination.page).toBe(0)
+      })
+    })
+
+    describe("selection", () => {
+      it("rowToggle: should select an unselected row", () => {
+        table.rowToggle(entity, 1)
+        expect(entity.selection).toContain(1)
+      })
+
+      it("rowToggle: should deselect a selected row", () => {
+        entity.selection = [1]
+        table.rowToggle(entity, 1)
+        expect(entity.selection).not.toContain(1)
+      })
+
+      it("rowToggle: should replace selection in single-select mode", () => {
+        entity.isMultiSelect = false
+        entity.selection = [1]
+        table.rowToggle(entity, 2)
+        expect(entity.selection).toEqual([2])
+      })
+
+      it("rowsToggleAll: should select all visible rows if not all are selected", () => {
+        entity.selection = [1] // Bob (id 3) is on page 2, so not visible
+        table.rowsToggleAll(entity) // Selects visible rows: Charlie (1), Alice (2)
+        expect(isAllSelected(entity)).toBe(true)
+        expect(entity.selection).toContain(1)
+        expect(entity.selection).toContain(2)
+      })
+
+      it("rowsToggleAll: should deselect all visible rows if all are selected", () => {
+        entity.selection = [1, 2] // All visible rows on page 0 are selected
+        table.rowsToggleAll(entity)
+        expect(entity.selection).toEqual([])
+      })
+    })
+
+    describe("getters and selectors", () => {
+      it("getRows: should return sorted, filtered, and paginated rows", () => {
+        // Sort by age descending
+        table.sortChange(entity, "age")
+        table.sortChange(entity, "age")
+        // Filter for active users
+        table.filterChange(entity, { columnId: "active", value: true })
+
+        // Expected after filter: Charlie (35), Alice (30), David (40)
+        // Expected after sort: David (40), Charlie (35), Alice (30)
+        // Expected after pagination (size 2): David (40), Charlie (35)
+        const rows = getRows(entity)
+        expect(rows.map((r) => r.name)).toEqual(["David", "Charlie"])
+      })
+
+      it("getTotalRows: should return total count after filtering", () => {
+        table.filterChange(entity, { columnId: "role", value: "Admin" })
+        expect(getTotalRows(entity)).toBe(2) // Charlie, David
+      })
+
+      it("getPaginationInfo: should return correct pagination details", () => {
+        const info = getPaginationInfo(entity)
+        expect(info).toEqual({
+          page: 0,
+          pageSize: 2,
+          totalPages: 2,
+          totalRows: 4,
+          start: 0,
+          end: 2,
+          hasNextPage: true,
+          hasPrevPage: false,
+        })
+      })
+
+      it("getSortDirection: should return the sort direction of a column", () => {
+        table.sortChange(entity, "name")
+        expect(getSortDirection(entity, "name")).toBe("asc")
+        expect(getSortDirection(entity, "age")).toBeNull()
+      })
+
+      it("isAllSelected: should return true if all visible rows are selected", () => {
+        entity.selection = [1, 2]
+        expect(isAllSelected(entity)).toBe(true)
+      })
+
+      it("isSomeSelected: should return true if some (but not all) visible rows are selected", () => {
+        entity.selection = [1]
+        expect(isSomeSelected(entity)).toBe(true)
+        entity.selection = [1, 2]
+        expect(isSomeSelected(entity)).toBe(false) // All are selected
+      })
+    })
+  })
+
+  describe("rendering", () => {
+    let api
+
+    beforeEach(() => {
+      // Mock the API and sub-renderers for focused testing
+      api = {
+        notify: vi.fn(),
+        getType: vi.fn().mockReturnValue({
+          ...table, // Use the real methods
+          renderHeader: vi.fn(() => html`<div>Header</div>`),
+          renderBody: vi.fn(() => html`<div>Body</div>`),
+          renderFooter: vi.fn(() => html`<div>Footer</div>`),
+        }),
+      }
+    })
+
+    it("render: should call sub-renderers", () => {
+      table.render(entity, api)
+      const type = api.getType()
+      expect(type.renderHeader).toHaveBeenCalledWith(entity, api)
+      expect(type.renderBody).toHaveBeenCalledWith(entity, api)
+      expect(type.renderFooter).toHaveBeenCalledWith(entity, api)
+    })
+
+    it("renderHeader: should render a header row with columns", () => {
+      // Use the real renderHeader
+      api.getType.mockReturnValue(table)
+      const result = table.renderHeader(entity, api)
+      const renderedItems = result.values.find(Array.isArray)
+      expect(renderedItems).toHaveLength(entity.columns.length)
+    })
+
+    it("renderHeaderColumn: should render a title and sort icon", () => {
+      table.sortChange(entity, "name") // sort asc
+      const column = entity.columns[0] // name column
+      const result = table.renderHeaderColumn(entity, column, api)
+      const renderedText = result.strings.join("")
+      const title = result.values[2]
+      const icon = result.values[3]
+      expect(renderedText).toContain("iw-table-header-title")
+      expect(`${title} ${icon}`).toBe("Name ▲")
+    })
+
+    it("renderBody: should render a row for each visible item", () => {
+      api.getType.mockReturnValue(table)
+      const result = table.renderBody(entity, api)
+      const [renderedRows] = result.values
+      const visibleRows = getRows(entity)
+      expect(renderedRows).toHaveLength(visibleRows.length)
+    })
+
+    it("renderRow: should render a row with correct classes", () => {
+      api.getType.mockReturnValue(table)
+      entity.selection = [1] // Select the first row
+      const rowData = entity.data[0] // Charlie
+
+      // The classMap directive is inside a string, making it hard to inspect.
+      // Instead, we can verify the logic that would be passed to it.
+      const isSelected = entity.selection?.includes(rowData.id)
+      const isEven = 0 % 2 !== 0 // The test passes index 0
+
+      // Assert that our logic correctly determines the class states.
+      expect(isEven).toBe(false)
+      expect(isSelected).toBe(true)
+    })
+
+    it("renderCell: should render a cell with correct style", () => {
+      api.getType.mockReturnValue(table)
+      const cellData = "Test"
+      const column = entity.columns[0] // name column
+      column.width = 150
+      const result = table.renderCell(entity, cellData, 0, api)
+      const styleString = result.values[1]
+      expect(styleString).toContain("width: 150px")
+    })
+
+    it("renderFooter: should render pagination info", () => {
+      api.getType.mockReturnValue(table)
+      // Ensure pagination is present for this test
+      entity.pagination = { page: 0, pageSize: 2 }
+      const result = table.renderFooter(entity, api)
+      // Reconstruct a simplified string from the template parts to check content
+      const renderedText = result.strings.reduce(
+        (acc, str, i) => acc + str + (result.values[i] ?? ""),
+        "",
+      )
+      // The reconstructed text might have extra whitespace, so we check for parts.
+      expect(renderedText).toContain("1 to 2 of 4")
+      expect(renderedText).toContain("entries")
+    })
+
+    it("renderPagination: should render page controls", () => {
+      api.getType.mockReturnValue(table)
+      entity.pagination = { page: 0, pageSize: 2 }
+      const paginationInfo = getPaginationInfo(entity)
+      const result = table.renderPagination(entity, paginationInfo, api)
+
+      // Reconstruct a simplified string from the template parts to check content
+      // This is more robust than inspecting the internal structure of lit-html's TemplateResult
+      const renderedText = result.strings.reduce(
+        (acc, str, i) => acc + str + (result.values[i] ?? ""),
+        "",
+      )
+      expect(renderedText).toContain('class="iw-table-page-input"')
+      expect(result.values).toContain(1) // Check that the dynamic value is correct
+    })
+
+    it("mount: should measure and set column widths", () => {
+      const mockColumn1 = document.createElement("div")
+      vi.spyOn(mockColumn1, "offsetWidth", "get").mockReturnValue(150)
+      const mockColumn2 = document.createElement("div")
+      vi.spyOn(mockColumn2, "offsetWidth", "get").mockReturnValue(200)
+
+      const containerEl = document.createElement("div")
+      containerEl.appendChild(mockColumn1)
+      containerEl.appendChild(mockColumn2)
+
+      // Only set width if it's a string (e.g., "auto")
+      entity.columns[0].width = "auto"
+      entity.columns[1].width = "auto"
+
+      table.mount(entity, containerEl)
+
+      expect(entity.columns[0].width).toBe(150)
+      expect(entity.columns[1].width).toBe(200)
+    })
+  })
+})

package/types/mount.d.ts

@@ -1,28 +1,7 @@
 import type { TemplateResult } from "lit-html"
 import type { Store, Api as StoreApi } from "@inglorious/store"
 
-/**
- * The result of a reactive selector.
- * @template T The type of the selected value.
- */
-export type ReactiveSelectorResult<T> = {
-  /** The current value of the selected state. */
-  readonly value: T
-  /** A function to stop listening for updates. */
-  unsubscribe: () => void
-}
-
 export type Api = StoreApi & {
-  /**
-   * Selects a slice of the application state and returns a reactive object.
-   * The value will update whenever the selected part of the state changes.
-   *
-   * @template T The type of the selected state slice.
-   * @param selectorFn A function that takes the API and returns a slice of the state.
-   * @returns A reactive result object with the current value and an unsubscribe function.
-   */
-  select: <T>(selectorFn: (api: Api) => T) => ReactiveSelectorResult<T>
-
   /**
    * Renders an entity or a type component by its ID.
    * @param id The ID of the entity or type to render.