@api-client/ui 0.5.39 → 0.5.40

package/test/elements/navigation/Navigation.test.ts

@@ -1,120 +0,0 @@
-import { html, fixture, assert, oneEvent, aTimeout } from '@open-wc/testing'
-import type Navigation from '../../../src/elements/navigation/internals/Navigation.js'
-import '../../../src/elements/navigation/ui-navigation.js'
-import '../../../src/elements/navigation/ui-navigation-item.js'
-
-describe('Navigation', () => {
-  it('renders with slot content', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation aria-label="Main navigation">
-        <ui-navigation-item selected aria-current="page">Home</ui-navigation-item>
-        <ui-navigation-item>Search</ui-navigation-item>
-        <ui-navigation-item>Files</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const nav = el.shadowRoot!.querySelector('nav')
-    assert.ok(nav, 'nav element is rendered')
-    assert.equal(nav?.getAttribute('aria-label'), 'Main navigation')
-    const items = el._items
-    assert.equal(items.length, 3)
-    assert.isTrue(items[0].selected)
-    assert.equal(items[0].getAttribute('aria-current'), 'page')
-  })
-
-  it('sets correct tabindex for items', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation>
-        <ui-navigation-item selected>Home</ui-navigation-item>
-        <ui-navigation-item>Search</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const items = el._items
-    assert.equal(items[0].getAttribute('tabindex'), '0')
-    assert.equal(items[1].getAttribute('tabindex'), '-1')
-  })
-
-  it('selects item on click and fires select event', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation>
-        <ui-navigation-item>Home</ui-navigation-item>
-        <ui-navigation-item>Search</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const items = el._items
-    setTimeout(() => items[1].click())
-    const ev = await oneEvent(el, 'select')
-    assert.equal(ev.detail.item, items[1])
-    assert.isTrue(items[1].selected)
-    assert.equal(items[1].getAttribute('tabindex'), '0')
-    assert.isFalse(items[0].selected)
-    assert.equal(items[0].getAttribute('tabindex'), '-1')
-  })
-
-  it('handles keyboard navigation (vertical)', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation>
-        <ui-navigation-item>Home</ui-navigation-item>
-        <ui-navigation-item>Search</ui-navigation-item>
-        <ui-navigation-item>Files</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const items = el._items
-    items[0].focus()
-    // ArrowDown moves to next
-    items[0].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }))
-    await aTimeout(0)
-    assert.dom.equal(document.activeElement, items[1])
-    // ArrowUp wraps to last
-    items[1].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp', bubbles: true }))
-    await aTimeout(0)
-    assert.dom.equal(document.activeElement, items[0])
-  })
-
-  it('handles keyboard navigation (horizontal)', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation orientation="horizontal">
-        <ui-navigation-item>Home</ui-navigation-item>
-        <ui-navigation-item>Search</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const items = el._items
-    items[0].focus()
-    items[0].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }))
-    await aTimeout(0)
-    assert.dom.equal(document.activeElement, items[1])
-    items[1].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowLeft', bubbles: true }))
-    await aTimeout(0)
-    assert.dom.equal(document.activeElement, items[0])
-  })
-
-  it('skips disabled items in navigation', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation>
-        <ui-navigation-item>Home</ui-navigation-item>
-        <ui-navigation-item disabled>Search</ui-navigation-item>
-        <ui-navigation-item>Files</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const items = el._items
-    items[0].focus()
-    items[0].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }))
-    await aTimeout(0)
-    // Should skip disabled and go to Files
-    assert.dom.equal(document.activeElement, items[2])
-  })
-
-  it('sets aria-current on selected item if current is set', async () => {
-    const el = await fixture<Navigation>(html`
-      <ui-navigation current="page">
-        <ui-navigation-item>Home</ui-navigation-item>
-        <ui-navigation-item>Search</ui-navigation-item>
-      </ui-navigation>
-    `)
-    const items = el._items
-    // Simulate user selection by clicking the item (public API)
-    items[1].click()
-    await aTimeout(0)
-    assert.equal(items[1].getAttribute('aria-current'), 'page')
-    assert.isFalse(items[0].hasAttribute('aria-current'))
-  })
-})

package/test/env.ts

@@ -1,15 +0,0 @@
-export interface Env {
-  oauth2: {
-    port: number
-    jwtKey: string
-    issuer: string
-  }
-}
-const value: Env = {
-  oauth2: {
-    port: 0,
-    jwtKey: '',
-    issuer: '',
-  },
-}
-export default value

package/test/events/EventTypes.test.ts

@@ -1,363 +0,0 @@
-import { assert } from '@open-wc/testing'
-import { ensureUnique } from './EventsTestHelpers.js'
-import { EventTypes } from '../../src/events/EventTypes.js'
-
-describe('events', () => {
-  describe('EventTypes', () => {
-    describe('HttpClient', () => {
-      describe('Workspace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.HttpClient.Workspace, 'object')
-        })
-
-        it('has the State namespace', () => {
-          assert.typeOf(EventTypes.HttpClient.Workspace.State, 'object')
-        })
-        ;[
-          ['read', 'httpclientwsread'],
-          ['write', 'httpclientwswrite'],
-          ['append', 'httpclientwsappend'],
-          ['triggerWrite', 'httpclientwstriggerwrite'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof Omit<typeof EventTypes.HttpClient.Workspace, 'State'>
-            assert.equal(EventTypes.HttpClient.Workspace[t], value)
-          })
-        })
-        ;[['write', 'httpclientwsstatewrite']].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.HttpClient.Workspace.State
-            assert.equal(EventTypes.HttpClient.Workspace.State[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.HttpClient.Workspace', EventTypes.HttpClient.Workspace)
-        })
-
-        it('has unique events on the State namespace', () => {
-          ensureUnique('EventTypes.HttpClient.Workspace.State', EventTypes.HttpClient.Workspace.State)
-        })
-      })
-    })
-
-    describe('SchemaDesign', () => {
-      it('has the namespace', () => {
-        assert.typeOf(EventTypes.SchemaDesign, 'object')
-      })
-      ;[['changed', 'schemadesignchange']].forEach(([prop, value]) => {
-        it(`has ${prop} property`, () => {
-          const t = prop as keyof Omit<typeof EventTypes.SchemaDesign, 'State'>
-          assert.equal(EventTypes.SchemaDesign[t], value)
-        })
-      })
-
-      it('has State namespace', () => {
-        assert.typeOf(EventTypes.SchemaDesign.State, 'object')
-      })
-      ;[['nameChanged', 'schemadesignnamechange']].forEach(([prop, value]) => {
-        it(`has ${prop} property`, () => {
-          const t = prop as keyof typeof EventTypes.SchemaDesign.State
-          assert.equal(EventTypes.SchemaDesign.State[t], value)
-        })
-      })
-
-      it('has unique events', () => {
-        ensureUnique('EventTypes.SchemaDesign', EventTypes.SchemaDesign)
-      })
-
-      it('has unique events on the State namespace', () => {
-        ensureUnique('EventTypes.SchemaDesign.State', EventTypes.SchemaDesign.State)
-      })
-    })
-
-    describe('HttpProject', () => {
-      describe('namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.HttpProject, 'object')
-        })
-        ;[['changed', 'httpprojectchange']].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof Omit<typeof EventTypes.SchemaDesign, 'State' | 'Ui'>
-            assert.equal(EventTypes.HttpProject[t], value)
-          })
-        })
-
-        it('has State namespace', () => {
-          assert.typeOf(EventTypes.HttpProject.State, 'object')
-        })
-        ;[['nameChanged', 'httpprojectnamechange']].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.HttpProject.State
-            assert.equal(EventTypes.HttpProject.State[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.HttpProject', EventTypes.HttpProject)
-        })
-
-        it('has unique events on the State namespace', () => {
-          ensureUnique('EventTypes.HttpProject.State', EventTypes.HttpProject.State)
-        })
-      })
-
-      describe('Ui namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.HttpProject.Ui, 'object')
-        })
-        ;[['delete', 'appdatauiprojectdelete']].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof Omit<typeof EventTypes.HttpProject.Ui, 'HttpRequest'>
-            assert.equal(EventTypes.HttpProject.Ui[t], value)
-          })
-        })
-
-        it('has HttpRequest namespace', () => {
-          assert.typeOf(EventTypes.HttpProject.Ui.HttpRequest, 'object')
-        })
-        ;[
-          ['set', 'appdatauiprojectrequestset'],
-          ['get', 'appdatauiprojectrequestget'],
-          ['delete', 'appdatauiprojectrequestdelete'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.HttpProject.Ui.HttpRequest
-            assert.equal(EventTypes.HttpProject.Ui.HttpRequest[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.HttpProject.Ui', EventTypes.HttpProject.Ui)
-        })
-
-        it('has unique events on the State namespace', () => {
-          ensureUnique('EventTypes.HttpProject.Ui.HttpRequest', EventTypes.HttpProject.Ui.HttpRequest)
-        })
-      })
-    })
-
-    describe('Http', () => {
-      describe('Request namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Http.Request, 'object')
-        })
-        ;[
-          ['send', 'requestsend'],
-          ['rename', 'requestrename'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof Omit<typeof EventTypes.Http.Request, 'State'>
-            assert.equal(EventTypes.Http.Request[t], value)
-          })
-        })
-
-        it('has State namespace', () => {
-          assert.typeOf(EventTypes.Http.Request.State, 'object')
-        })
-        ;[
-          ['urlChange', 'requeststateurlchange'],
-          ['contentTypeChange', 'requeststatecontenttypechange'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.Http.Request.State
-            assert.equal(EventTypes.Http.Request.State[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Http.Request', EventTypes.Http.Request)
-        })
-
-        it('has unique events on the State namespace', () => {
-          ensureUnique('EventTypes.Http.Request.State', EventTypes.Http.Request.State)
-        })
-      })
-    })
-
-    describe('Store', () => {
-      describe('Store namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Store, 'object')
-        })
-        ;[
-          ['info', 'storebackendinfo'],
-          ['initEnvironment', 'configstoreinitenv'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof Omit<
-              typeof EventTypes.Store,
-              'Global' | 'Auth' | 'File' | 'User' | 'History' | 'ProjectRuns'
-            >
-            assert.equal(EventTypes.Store[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Store', EventTypes.Store)
-        })
-      })
-
-      describe('Global namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Store, 'object')
-        })
-        ;[
-          ['setEnv', 'storesetgloablenvironment'],
-          ['getEnv', 'storegetgloablenvironment'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.Store.Global
-            assert.equal(EventTypes.Store.Global[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Store.Global', EventTypes.Store.Global)
-        })
-      })
-
-      describe('Auth namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Store, 'object')
-        })
-        ;[
-          ['isAuthenticated', 'storeaisauthenticated'],
-          ['authenticate', 'storeauthenticate'],
-          ['getToken', 'storeauthgettoken'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.Store.Auth
-            assert.equal(EventTypes.Store.Auth[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Store.Auth', EventTypes.Store.Auth)
-        })
-      })
-
-      describe('File namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Store, 'object')
-        })
-        ;[
-          ['list', 'storefileslist'],
-          ['listShared', 'storefileslistshared'],
-          ['create', 'storefilescreate'],
-          ['createDefault', 'storefilescreatedefault'],
-          ['read', 'storefilesread'],
-          ['patch', 'storefilespatch'],
-          ['delete', 'storefilesdelete'],
-          ['patchUsers', 'storefilespatchusers'],
-          ['listUsers', 'storefileslistusers'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.Store.File
-            assert.equal(EventTypes.Store.File[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Store.File', EventTypes.Store.File)
-        })
-      })
-
-      describe('User namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Store, 'object')
-        })
-        ;[
-          ['me', 'storeuserme'],
-          ['list', 'storeuserlist'],
-          ['read', 'storeuserread'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.Store.User
-            assert.equal(EventTypes.Store.User[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Store.User', EventTypes.Store.User)
-        })
-      })
-
-      describe('History namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Store, 'object')
-        })
-        ;[
-          ['create', 'storehistorycreate'],
-          ['createBulk', 'storehistorycreatebulk'],
-          ['list', 'storehistorylist'],
-          ['delete', 'storehistorydelete'],
-          ['read', 'storehistoryread'],
-        ].forEach(([prop, value]) => {
-          it(`has ${prop} property`, () => {
-            const t = prop as keyof typeof EventTypes.Store.History
-            assert.equal(EventTypes.Store.History[t], value)
-          })
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Store.History', EventTypes.Store.History)
-        })
-      })
-    })
-
-    describe('Config', () => {
-      describe('Session namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Config.Session, 'object')
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Config.Session', EventTypes.Config.Session)
-        })
-      })
-
-      describe('Local namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Config.Local, 'object')
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Config.Local', EventTypes.Config.Local)
-        })
-      })
-
-      describe('Telemetry namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Config.Telemetry, 'object')
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Config.Telemetry', EventTypes.Config.Telemetry)
-        })
-      })
-    })
-
-    describe('Navigation', () => {
-      describe('App namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Navigation.App, 'object')
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Navigation.App', EventTypes.Navigation.App)
-        })
-      })
-
-      describe('Store namespace', () => {
-        it('has the namespace', () => {
-          assert.typeOf(EventTypes.Navigation.Store, 'object')
-        })
-
-        it('has unique events', () => {
-          ensureUnique('EventTypes.Navigation.Store', EventTypes.Navigation.Store)
-        })
-      })
-    })
-  })
-})

package/test/events/EventsTestHelpers.ts

@@ -1,16 +0,0 @@
-// The event names should be unique across all events in all modules.
-const names: string[] = []
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function ensureUnique(namespace: string, src: any): void {
-  for (const [key, value] of Object.entries(src)) {
-    const typedValue = value as string
-    if (typeof typedValue !== 'string') {
-      return
-    }
-    if (names.includes(typedValue)) {
-      throw new Error(`${namespace}.${key} has duplicated event name ${typedValue}`)
-    }
-    names.push(typedValue)
-  }
-}