@api-client/ui 0.1.6 → 0.1.8

package/test/core/activity_manager.spec.ts

@@ -5,7 +5,7 @@ import { Activity } from '../../src/core/Activity.js'
 import { Application } from '../../src/core/Application.js'
 import {
   ActivityManager,
-  ActivityState,
+  ActivityLifecycle,
   IntentFlags,
   IntentResult,
   type Intent,
@@ -41,7 +41,7 @@ class TestActivity extends Activity {
     this.setResult.resetHistory()
     this.getResult.resetHistory()
     this.hasRequestCode.resetHistory()
-    this.state = ActivityState.Initialized
+    this.lifecycle = ActivityLifecycle.Initialized
     this.pendingRequestCodes.length = 0
     this.exitCode = IntentResult.RESULT_CANCELED
     this.resultData = undefined
@@ -114,7 +114,7 @@ describe('ActivityManager', () => {
       assert.equal(manager['activityStack'].length, 1)
       const entry = manager['activityStack'][0]
       assert.instanceOf(entry.activity, TestActivity)
-      assert.equal(entry.activity.state, ActivityState.Initialized)
+      assert.equal(entry.activity.lifecycle, ActivityLifecycle.Initialized)
       assert.strictEqual(entry.intent, intent)
       assert.isUndefined(manager.getCurrentActivity())
     })
@@ -142,7 +142,7 @@ describe('ActivityManager', () => {
       assert.isTrue((entry.activity as TestActivity).onCreate.calledOnceWith(intent))
       assert.isTrue((entry.activity as TestActivity).onStart.calledOnce)
       assert.isTrue((entry.activity as TestActivity).onResume.calledOnce)
-      assert.equal(entry.activity.state, ActivityState.Resumed)
+      assert.equal(entry.activity.lifecycle, ActivityLifecycle.Resumed)
       // assert.isFalse(navigateScreenStub.called) // No URI in intent
     })
 
@@ -162,12 +162,12 @@ describe('ActivityManager', () => {
       await manager.startActivity(intent2)
       const activity2 = manager.getCurrentActivity() as TestActivity
       assert.isTrue(activity1.onPause.calledOnce, 'activity1 onPause should be called once')
-      assert.equal(activity1.state, ActivityState.Paused, 'activity1 should be paused')
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Paused, 'activity1 should be paused')
 
       assert.isTrue(activity2.onCreate.calledOnceWith(intent2), 'activity2 onCreate should be called with intent')
       assert.isTrue(activity2.onStart.calledOnce, 'activity2 onStart should be called once')
       assert.isTrue(activity2.onResume.calledOnce, 'activity2 onResume should be called once')
-      assert.equal(activity2.state, ActivityState.Resumed, 'activity2 should be resumed')
+      assert.equal(activity2.lifecycle, ActivityLifecycle.Resumed, 'activity2 should be resumed')
       assert.equal(manager['activityStack'].length, 2, 'activity stack should have 2 activities')
     })
 
@@ -182,8 +182,8 @@ describe('ActivityManager', () => {
       const activity2 = manager.getCurrentActivity() as TestActivity
 
       // activity1 is now paused, activity2 is resumed
-      assert.equal(activity1.state, ActivityState.Paused, 'activity1 should be paused')
-      assert.equal(activity2.state, ActivityState.Resumed, 'activity2 should be resumed')
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Paused, 'activity1 should be paused')
+      assert.equal(activity2.lifecycle, ActivityLifecycle.Resumed, 'activity2 should be resumed')
 
       const newIntentForActivity1: Intent = { action: TestActivity.action, data: { updated: true } }
       await manager.startActivity(newIntentForActivity1)
@@ -191,10 +191,10 @@ describe('ActivityManager', () => {
       assert.strictEqual(manager.getCurrentActivity(), activity1)
       assert.isTrue(activity1.onNewIntent.calledOnceWith(newIntentForActivity1), 'activity1 called with new intent')
       assert.isTrue(activity1.onResume.calledOnce, 'activity1 onResume called once') // Should be resumed
-      assert.equal(activity1.state, ActivityState.Resumed, 'activity1 should be resumed')
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Resumed, 'activity1 should be resumed')
 
       assert.isTrue(activity2.onPause.calledOnce, 'activity2 paused once') // activity2 should be paused
-      assert.equal(activity2.state, ActivityState.Paused, 'activity2 should be paused')
+      assert.equal(activity2.lifecycle, ActivityLifecycle.Paused, 'activity2 should be paused')
 
       assert.equal(manager['activityStack'].length, 2, 'activityStack is the same') // Stack size remains the same
       assert.strictEqual(manager['activityStack'][1].activity, activity1) // activity1 is now at the top
@@ -214,14 +214,14 @@ describe('ActivityManager', () => {
       assert.strictEqual(manager['modalActivityStack'][0].activity, modalActivity)
 
       assert.isTrue(activity1.onPause.calledOnce)
-      assert.equal(activity1.state, ActivityState.Paused)
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Paused)
       // For modal, currentActivity in manager should still be the underlying one
       assert.strictEqual(manager.getCurrentActivity(), activity1)
 
       assert.isTrue(modalActivity.onCreate.calledOnceWith(modalIntent))
       assert.isTrue(modalActivity.onStart.calledOnce)
       assert.isTrue(modalActivity.onResume.calledOnce)
-      assert.equal(modalActivity.state, ActivityState.Resumed)
+      assert.equal(modalActivity.lifecycle, ActivityLifecycle.Resumed)
     })
 
     it('throws if activity class is not registered', async () => {
@@ -301,11 +301,11 @@ describe('ActivityManager', () => {
       assert.isTrue(activity2.onPause.calledOnce, 'activity2 onPause should be called once')
       assert.isTrue(activity2.onStop.calledOnce, 'activity2 onStop should be called once')
       assert.isTrue(activity2.onDestroy.calledOnce, 'activity2 onDestroy should be called once')
-      assert.equal(activity2.state, ActivityState.Destroyed, 'activity2 should be destroyed')
+      assert.equal(activity2.lifecycle, ActivityLifecycle.Destroyed, 'activity2 should be destroyed')
 
       assert.strictEqual(manager.getCurrentActivity(), activity1)
       assert.isTrue(activity1.onResume.calledOnce, 'activity1 onResume should be called once')
-      assert.equal(activity1.state, ActivityState.Resumed, 'activity1 should be resumed')
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Resumed, 'activity1 should be resumed')
       assert.equal(manager['activityStack'].length, 1, 'activity stack should have 1 activity')
       assert.isTrue(app.requestUpdateSpy.called, 'Application should request update after finishing activity')
     })
@@ -325,12 +325,12 @@ describe('ActivityManager', () => {
       assert.isTrue(modalActivity.onPause.calledOnce)
       assert.isTrue(modalActivity.onStop.calledOnce)
       assert.isTrue(modalActivity.onDestroy.calledOnce)
-      assert.equal(modalActivity.state, ActivityState.Destroyed)
+      assert.equal(modalActivity.lifecycle, ActivityLifecycle.Destroyed)
       assert.equal(manager['modalActivityStack'].length, 0)
 
       assert.strictEqual(manager.getCurrentActivity(), activity1) // Current activity should be the underlying one
       assert.isTrue(activity1.onResume.calledOnce)
-      assert.equal(activity1.state, ActivityState.Resumed)
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Resumed)
       assert.equal(manager['activityStack'].length, 1)
     })
 
@@ -362,13 +362,13 @@ describe('ActivityManager', () => {
 
     it('handles finishing an activity that was only created (not fully started)', async () => {
       const activity = new TestActivity(app)
-      activity.state = ActivityState.Created // Manually set for test
+      activity.lifecycle = ActivityLifecycle.Created // Manually set for test
 
       await manager.finishActivity(activity)
 
       assert.isTrue(activity.onStop.calledOnce, 'onStop should be called for created activity')
       assert.isTrue(activity.onDestroy.calledOnce, 'onDestroy should be called')
-      assert.equal(activity.state, ActivityState.Destroyed)
+      assert.equal(activity.lifecycle, ActivityLifecycle.Destroyed)
       assert.isUndefined(manager.getCurrentActivity()) // Assuming no other activities
     })
 
@@ -380,7 +380,7 @@ describe('ActivityManager', () => {
       await manager.finishActivity(activity1)
 
       assert.isTrue(activity1.onDestroy.calledOnce)
-      assert.equal(activity1.state, ActivityState.Destroyed)
+      assert.equal(activity1.lifecycle, ActivityLifecycle.Destroyed)
       assert.isUndefined(manager.getCurrentActivity())
       assert.equal(manager['activityStack'].length, 0)
     })
@@ -394,11 +394,11 @@ describe('ActivityManager', () => {
     it('returns the top resumed regular activity', async () => {
       await manager.startActivity({ action: TestActivity.action })
       const activity1 = manager['activityStack'][0].activity
-      activity1.state = ActivityState.Resumed // Ensure it's resumed
+      activity1.lifecycle = ActivityLifecycle.Resumed // Ensure it's resumed
 
       await manager.startActivity({ action: TestActivity2.action })
       const activity2 = manager['activityStack'][1].activity
-      activity2.state = ActivityState.Resumed // Ensure it's resumed
+      activity2.lifecycle = ActivityLifecycle.Resumed // Ensure it's resumed
 
       assert.strictEqual(manager.getTopActivity(), activity2)
     })
@@ -406,11 +406,11 @@ describe('ActivityManager', () => {
     it('returns the top resumed modal activity if present', async () => {
       await manager.startActivity({ action: TestActivity.action }) // Regular activity
       const regularActivity = manager['activityStack'][0].activity
-      regularActivity.state = ActivityState.Resumed
+      regularActivity.lifecycle = ActivityLifecycle.Resumed
 
       await manager.startActivity({ action: TestActivity2.action, flags: IntentFlags.Modal })
       const modalActivity = manager['modalActivityStack'][0].activity
-      modalActivity.state = ActivityState.Resumed // Ensure it's resumed
+      modalActivity.lifecycle = ActivityLifecycle.Resumed // Ensure it's resumed
 
       assert.strictEqual(manager.getTopActivity(), modalActivity)
     })
@@ -421,8 +421,8 @@ describe('ActivityManager', () => {
 
       await manager.startActivity({ action: TestActivity2.action, flags: IntentFlags.Modal })
       const modalActivity = manager['modalActivityStack'][0].activity
-      modalActivity.state = ActivityState.Paused // Not resumed
-      regularActivity.state = ActivityState.Resumed
+      modalActivity.lifecycle = ActivityLifecycle.Paused // Not resumed
+      regularActivity.lifecycle = ActivityLifecycle.Resumed
       assert.strictEqual(manager.getTopActivity(), regularActivity)
     })
   })

package/test/core/application.spec.ts

@@ -3,7 +3,7 @@ import sinon from 'sinon'
 import { fixture, html } from '@open-wc/testing'
 import { Application, type UpdateRequest } from '../../src/core/Application.js'
 import { Activity } from '../../src/core/Activity.js'
-import { ActivityManager, ActivityState } from '../../src/core/ActivityManager.js'
+import { ActivityManager, ActivityLifecycle } from '../../src/core/ActivityManager.js'
 import { ApplicationRenderer } from '../../src/core/renderer/ApplicationRenderer.js'
 import { ThemeManager } from '../../src/core/ThemeManager.js'
 import { nothing } from 'lit'
@@ -136,12 +136,12 @@ describe('Application', () => {
       await app.run() // This calls onStart which registers TestActivity
       await app.manager.startActivity({ action: TestActivity.action })
       const activity = app.getCurrentActivity() as TestActivity
-      activity.state = ActivityState.Started // Ensure state
+      activity.lifecycle = ActivityLifecycle.Started // Ensure state
 
       app.render()
       assert.isTrue(activity.renderSpy.calledOnce)
 
-      activity.state = ActivityState.Resumed // Ensure state
+      activity.lifecycle = ActivityLifecycle.Resumed // Ensure state
       activity.renderSpy.resetHistory()
       app.render()
       assert.isTrue(activity.renderSpy.calledOnce)

package/test/core/fragment.spec.ts

@@ -5,7 +5,7 @@ import { Fragment } from '../../src/core/Fragment.js'
 import { Activity } from '../../src/core/Activity.js'
 import { Application } from '../../src/core/Application.js'
 import { FragmentState, FragmentManager } from '../../src/core/FragmentManager.js'
-import { IntentResult, type Intent, ActivityState } from '../../src/core/ActivityManager.js'
+import { IntentResult, type Intent, ActivityLifecycle } from '../../src/core/ActivityManager.js'
 import { FragmentRenderer } from '../../src/core/renderer/FragmentRenderer.js'
 import { EventTypes } from '../../src/events/EventTypes.js'
 import { nothing } from 'lit'
@@ -107,7 +107,7 @@ describe('Fragment', () => {
     app = new TestApplication(renderRoot)
     await app.run() // To register activity
     activity = new TestActivity(app) // Parent for the fragment
-    activity.state = ActivityState.Resumed // Mock activity as active
+    activity.lifecycle = ActivityLifecycle.Resumed // Mock activity as active
     fragment = new TestFragment({ parent: activity })
   })
 

package/test/core/live_data.spec.ts

@@ -61,10 +61,40 @@ describe('LiveData Basic', () => {
 
     liveData.value.items.push('orange')
 
-    assert.equal(spy.callCount, 1)
+    assert.equal(spy.callCount, 1, 'called once for the push')
     const args = spy.args[0][0].detail
-    assert.equal(args.path, 'items.2')
-    assert.equal(args.value, 'orange')
+    assert.equal(args.path, 'items.2', 'path is correct')
+    assert.equal(args.value, 'orange', 'value is correct')
+  })
+
+  it('should handle sets', () => {
+    const data = { set: new Set(['apple', 'banana']) }
+    const liveData = new LiveData(data)
+
+    const spy = sinon.spy()
+    liveData.addEventListener('update', spy)
+
+    liveData.value.set.add('orange')
+
+    assert.equal(spy.callCount, 1, 'called once for the add')
+    const args = spy.args[0][0].detail
+    assert.equal(args.path, 'set', 'path is correct')
+    assert.deepEqual(args.value, data.set, 'value is correct')
+  })
+
+  it('should handle maps', () => {
+    const data = { map: new Map([['a', 'b']]) }
+    const liveData = new LiveData(data)
+
+    const spy = sinon.spy()
+    liveData.addEventListener('update', spy)
+
+    liveData.value.map.set('c', 'd')
+
+    assert.equal(spy.callCount, 1, 'called once for the add')
+    const args = spy.args[0][0].detail
+    assert.equal(args.path, 'map', 'path is correct')
+    assert.deepEqual(args.value, data.map, 'value is correct')
   })
 
   it('should handle arrays with array index', () => {

package/test/elements/data-table/DataTable.browser.test.ts

@@ -73,11 +73,8 @@ describe('DataTable', () => {
   describe('Basic tests', () => {
     it('renders the table with correct number of rows and columns', async () => {
       const items = generateItems(3)
-      // console.log('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
       const element = await basicFixture<TestItem>(items)
-      // console.log('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
       await nextFrame()
-      // console.log('ccccccccccccccccccccccccccccccccccc')
       const rows = element.shadowRoot!.querySelectorAll('tr')
       assert.equal(rows.length, items.value.length + 1, 'has all rows') // +1 for header row