@lightningjs/blits 1.30.1 → 1.31.0

package/src/lib/colors/colors.test.js

@@ -1,290 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import test from 'tape'
-import colors from './colors.js'
-
-test('Object', (assert) => {
-  const expected = 'object'
-  const actual = typeof colors
-
-  assert.equal(actual, expected, 'Colors should be an object')
-  assert.end()
-})
-
-test('6 character hex', (assert) => {
-  const input = [
-    '#ffffff',
-    '#000000',
-    '#c0ffee',
-    '#7dd3fc',
-    '#0c4a6e',
-    'ffffff',
-    '000000',
-    'c0ffee',
-    '7dd3fc',
-    '0c4a6e',
-  ]
-  const expected = [
-    '0xffffffff',
-    '0x000000ff',
-    '0xc0ffeeff',
-    '0x7dd3fcff',
-    '0x0c4a6eff',
-    '0xffffffff',
-    '0x000000ff',
-    '0xc0ffeeff',
-    '0x7dd3fcff',
-    '0x0c4a6eff',
-  ]
-
-  const actual = input.map(colors.normalize)
-
-  assert.deepEqual(
-    actual,
-    expected,
-    'A 6 character hex code should return the correct color in rgba format'
-  )
-  assert.end()
-})
-
-test('3 character hex', (assert) => {
-  const input = ['#fff', '#000', '#c8c', 'fff', '000', 'c8c']
-  const expected = [
-    '0xffffffff',
-    '0x000000ff',
-    '0xcc88ccff',
-    '0xffffffff',
-    '0x000000ff',
-    '0xcc88ccff',
-  ]
-
-  const actual = input.map(colors.normalize)
-
-  assert.deepEqual(
-    actual,
-    expected,
-    'A 3 character hex code should return the correct color in rgba format'
-  )
-  assert.end()
-})
-
-test('8 character hex (rgba)', (assert) => {
-  const input = [
-    '#ffffffff',
-    '#000000ff',
-    '#c0ffee80',
-    '#7dd3fc10',
-    '#0c4a6eff',
-    'ffffffff',
-    '000000ff',
-    'c0ffee80',
-    '7dd3fc10',
-    '0c4a6eff',
-  ]
-  const expected = [
-    '0xffffffff',
-    '0x000000ff',
-    '0xc0ffee80',
-    '0x7dd3fc10',
-    '0x0c4a6eff',
-    '0xffffffff',
-    '0x000000ff',
-    '0xc0ffee80',
-    '0x7dd3fc10',
-    '0x0c4a6eff',
-  ]
-
-  const actual = input.map(colors.normalize)
-
-  assert.deepEqual(
-    actual,
-    expected,
-    'A 8 character hex (rgba) code should return the correct color in rgba format'
-  )
-  assert.end()
-})
-
-test('Invalid hex values', (assert) => {
-  const input = [
-    '#fde4',
-    '#1000',
-    '#ddc8c',
-    'hg0',
-    '000fffa',
-    '#a',
-    '#0',
-    'c8O',
-    'fffff',
-    '000f00000',
-    '##000000',
-  ]
-  const expected = [
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-  ]
-
-  const actual = input.map((color) => colors.normalize(color))
-
-  assert.deepEqual(
-    actual,
-    expected,
-    'Invalid hex values should return white color as the default color'
-  )
-  assert.end()
-})
-
-test('RGB colors', (assert) => {
-  const input = [
-    'rgb(255,255,255)',
-    'rgb(0,0,0)',
-    'rgb(192, 255, 238)',
-    'rgb(125, 211, 252)',
-    'rgb(12, 74, 110)',
-  ]
-  const expected = ['0xffffffff', '0x000000ff', '0xc0ffeeff', '0x7dd3fcff', '0x0c4a6eff']
-
-  const actual = input.map(colors.normalize)
-
-  assert.deepEqual(actual, expected, 'RGB codes should return the correct color in rgba format')
-  assert.end()
-})
-
-test('Invalid RGB colors', (assert) => {
-  const input = [
-    'rgb(256,255,255)',
-    'rgb(123,432,211)',
-    'rgb(192, 255)',
-    'rgb(125,, 211, 252)',
-    'rgb(-12, 74, 110)',
-  ]
-  const expected = ['0xffffffff', '0xffffffff', '0xffffffff', '0xffffffff', '0xffffffff']
-
-  const actual = input.map((color) => colors.normalize(color))
-
-  assert.deepEqual(actual, expected, 'Invalid RGB codes should return white color in rgba format')
-  assert.end()
-})
-
-test('RGBA colors', (assert) => {
-  const input = [
-    'rgba(255,255,255,1)',
-    'rgba(0,0,0,1)',
-    'rgba(192, 255, 238, 0.5)',
-    'rgba(125, 211, 252, 0.1)',
-    'rgba(12, 74, 110, 0)',
-    'rgba(12, 74, 110, -0.5)', // negative alpha should become 0
-    'rgba(12, 74, 110, 1.2)', // highher than 1 alpha should become 1
-  ]
-  const expected = [
-    '0xffffffff',
-    '0x000000ff',
-    '0xc0ffee80',
-    '0x7dd3fc1a',
-    '0x0c4a6e00',
-    '0x0c4a6e00',
-    '0x0c4a6eff',
-  ]
-
-  const actual = input.map(colors.normalize)
-
-  assert.deepEqual(actual, expected, 'RGBA codes should return the correct color in rgba format')
-  assert.end()
-})
-
-test('Invalid RGBA colors', (assert) => {
-  const input = [
-    'rgb(255,255,255,1)',
-    'rgba(0,0,0,a)',
-    'rgba(192, 256, 238, 0.5)',
-    'rgba(125, 252, 0.1)',
-    'rgba(12,, 74, 110, 0)',
-    'rgba(-12, 74, 110, -0.5)',
-    'rgba(12, 74, 110, --1.2)',
-  ]
-  const expected = [
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-    '0xffffffff',
-  ]
-
-  const actual = input.map((color) => colors.normalize(color))
-
-  assert.deepEqual(actual, expected, 'Invalid RGBA codes should return white color in rgba format')
-  assert.end()
-})
-
-test('HTML colors', (assert) => {
-  const input = ['blanchedalmond', 'salmon', 'tomato', 'saddlebrown', 'red']
-  const expected = ['0xffebcdff', '0xfa8072ff', '0xff6347ff', '0x8b4513ff', '0xff0000ff']
-
-  const actual = input.map(colors.normalize)
-
-  assert.deepEqual(
-    actual,
-    expected,
-    'HTML color codes should return the correct color in rgba format'
-  )
-  assert.end()
-})
-
-test('Invalid HTML colors', (assert) => {
-  const input = ['darkblanchedalmond', 'selmon', 'lighttomato', 'sadlebrown', 'darkbrown']
-  const expected = ['0xffffffff', '0xffffffff', '0xffffffff', '0xffffffff', '0xffffffff']
-
-  const actual = input.map((color) => colors.normalize(color))
-
-  assert.deepEqual(
-    actual,
-    expected,
-    'Invalid HTML color codes should return white color in rgba format'
-  )
-  assert.end()
-})
-
-// test('hsl', (assert) => {
-//   const input = [
-//     'hsl(0,0,100)',
-//     'hsl(0,0, 0)',
-//     'hsl(164,100,88)',
-//     'hsl(199,95,74)',
-//     'hsl(202,80,24)',
-//   ]
-//   const expected = ['0xffffffff', '0xff000000', '0xffeeffc0', '0xfffcd37d', '0xff6e4a0c']
-
-//   const actual = input.map(colors.normalize)
-
-//   assert.deepEqual(actual, expected, 'A hsl code should return the correct color in rgba format')
-//   assert.end()
-// })
-
-// hls()
-// hlsa()
-// html color (red, blue, pink)

package/src/lib/componentId.test.js

@@ -1,84 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import test from 'tape'
-import { createHumanReadableId, createInternalId, resetCounter } from './componentId.js'
-
-test('Type createHumandReadableId', (assert) => {
-  const expected = 'function'
-  const actual = typeof createHumanReadableId
-
-  assert.equal(actual, expected, 'createHumanReadableId should be a function')
-  assert.end()
-})
-
-test('Returns a readable id, based on a counter and component name', (assert) => {
-  const expected = 'BlitsComponent::Spinner_1'
-  const actual = createHumanReadableId('Spinner')
-
-  assert.equal(actual, expected, 'createHumanReadableId should return correct ID')
-  assert.end()
-})
-
-test('Returns a readable id with incremented count', (assert) => {
-  const expected = 'BlitsComponent::Spinner_2'
-  const actual = createHumanReadableId('Spinner')
-
-  assert.equal(actual, expected, 'createHumanReadableId should return correct ID')
-  assert.end()
-})
-
-test('Has a seperate count per component name', (assert) => {
-  const expected = 'BlitsComponent::Card_1'
-  const actual = createHumanReadableId('Card')
-
-  assert.equal(actual, expected, 'createHumanReadableId should return correct ID')
-  assert.end()
-})
-
-test('Type createInternalId', (assert) => {
-  const expected = 'function'
-  const actual = typeof createInternalId
-
-  assert.equal(actual, expected, 'createInternalId should be a function')
-  assert.end()
-})
-
-test('Returns an internal id, disregarding the component name', (assert) => {
-  resetCounter()
-  const expected = 1
-  const actual = createInternalId('Spinner')
-
-  assert.equal(actual, expected, 'createInternalId should return correct ID')
-  assert.end()
-})
-
-test('Returns an id with incremented counter', (assert) => {
-  const expected = 2
-  const actual = createInternalId('Spinner')
-
-  assert.equal(actual, expected, 'createInternalId should return correct ID')
-  assert.end()
-})
-
-test('Uses the same counter for all components', (assert) => {
-  const expected = 3
-  const actual = createInternalId('Card')
-
-  assert.equal(actual, expected, 'createInternalId should return correct ID')
-  assert.end()
-})

package/src/lib/eventListeners.test.js

@@ -1,236 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import test from 'tape'
-import eventListener from './eventListeners.js'
-
-const resetModule = () => {
-  eventListener.removeListeners('testComponent')
-  eventListener.removeListeners('anotherComponent')
-}
-
-test('registerListener', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event = 'testEvent'
-  const cb = () => {}
-
-  t.doesNotThrow(
-    () => eventListener.registerListener(component, event, cb),
-    'Should not throw exception when registering a listener'
-  )
-
-  t.doesNotThrow(
-    () => eventListener.registerListener(component, event, cb, 1),
-    'Should not throw exception when registering a listener with priority'
-  )
-
-  t.doesNotThrow(
-    () => eventListener.registerListener('anotherComponent', event, cb),
-    'Should not throw exception when registering multiple components for the same event'
-  )
-
-  t.end()
-})
-
-test('executeListeners - no listeners', (t) => {
-  resetModule()
-
-  const result = eventListener.executeListeners('nonExistentEvent')
-  t.equal(result, true, 'Should return true when no listeners are registered')
-
-  t.end()
-})
-
-test('executeListeners - with listeners', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event = 'testEvent'
-  let callCount = 0
-  const cb1 = () => {
-    callCount++
-  }
-  const cb2 = () => {
-    callCount++
-  }
-
-  eventListener.registerListener(component, event, cb1)
-  eventListener.registerListener(component, event, cb2)
-
-  const result = eventListener.executeListeners(event)
-  t.equal(result, true, 'Should return true when all listeners execute successfully')
-  t.equal(callCount, 2, 'Should call all registered callbacks')
-
-  t.end()
-})
-
-test('executeListeners - priority order', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event = 'testEvent'
-  const order = []
-  const cb1 = () => {
-    order.push(1)
-  }
-  const cb2 = () => {
-    order.push(2)
-  }
-  const cb3 = () => {
-    order.push(3)
-  }
-
-  eventListener.registerListener(component, event, cb1, 1)
-  eventListener.registerListener(component, event, cb2, 3)
-  eventListener.registerListener(component, event, cb3, 2)
-
-  eventListener.executeListeners(event)
-  t.deepEqual(order, [2, 3, 1], 'Should execute callbacks in priority order')
-
-  t.end()
-})
-
-test('executeListeners - stop propagation', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event = 'testEvent'
-  let callCount = 0
-  const cb1 = () => {
-    callCount++
-    return false
-  }
-  const cb2 = () => {
-    callCount++
-  }
-
-  eventListener.registerListener(component, event, cb1)
-  eventListener.registerListener(component, event, cb2)
-
-  const result = eventListener.executeListeners(event)
-  t.equal(result, false, 'Should return false when propagation is stopped')
-  t.equal(callCount, 1, 'Should stop calling callbacks after one returns false')
-
-  t.end()
-})
-
-test('deregisterListener', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event = 'testEvent'
-  let callCount = 0
-  const cb = () => {
-    callCount++
-  }
-
-  eventListener.registerListener(component, event, cb)
-  eventListener.deregisterListener(component, event)
-
-  const result = eventListener.executeListeners(event)
-  t.equal(result, true, 'Should return true when no listeners are registered after deregistration')
-  t.equal(callCount, 0, 'Should not call deregistered callback')
-
-  t.end()
-})
-
-test('deregisterListener - only deregisters specified component listener', (t) => {
-  resetModule()
-
-  const componentA = 'testComponent'
-  const componentB = 'testComponentB'
-  const event = 'testEvent'
-  let callCount1 = 0
-  let callCount2 = 0
-
-  eventListener.registerListener(componentA, event, () => {
-    callCount1++
-  })
-
-  eventListener.registerListener(componentB, event, () => {
-    callCount2++
-  })
-
-  eventListener.deregisterListener(componentA, event)
-
-  const result = eventListener.executeListeners(event)
-  t.equal(
-    result,
-    true,
-    'Should return true when listeners are still registered after deregistering one'
-  )
-  t.equal(callCount1, 0, 'Should not call deregistered callback')
-  t.equal(callCount2, 1, 'Should call remaining registered callback')
-
-  t.end()
-})
-
-test('removeListeners', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event1 = 'testEvent1'
-  const event2 = 'testEvent2'
-  const cb = () => {}
-
-  eventListener.registerListener(component, event1, cb)
-  eventListener.registerListener(component, event2, cb)
-  eventListener.registerListener('anotherComponent', event1, cb)
-
-  eventListener.removeListeners(component)
-
-  const result1 = eventListener.executeListeners(event1)
-  t.equal(result1, true, 'Should still return true for event1 as another component is registered')
-
-  const result2 = eventListener.executeListeners(event2)
-  t.equal(result2, true, 'Should return true for event2 as no listeners remain')
-
-  t.end()
-})
-
-test('cache invalidation', (t) => {
-  resetModule()
-
-  const component = 'testComponent'
-  const event = 'testEvent'
-  let callOrder = []
-  const cb1 = () => {
-    callOrder.push(1)
-  }
-  const cb2 = () => {
-    callOrder.push(2)
-  }
-
-  eventListener.registerListener(component, event, cb1)
-  eventListener.executeListeners(event)
-
-  eventListener.registerListener(component, event, cb2, 1)
-  eventListener.executeListeners(event)
-
-  t.deepEqual(callOrder, [1, 2, 1], 'Should invalidate cache when new listener is added')
-
-  callOrder = []
-  eventListener.removeListeners(component)
-  eventListener.registerListener(component, event, cb1)
-  eventListener.executeListeners(event)
-
-  t.deepEqual(callOrder, [1], 'Should invalidate cache when listeners are removed')
-
-  t.end()
-})

package/src/lib/reactivity/effect.test.js

@@ -1,35 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import test from 'tape'
-import { trigger, track } from './effect.js'
-
-test('Trigger - type', (assert) => {
-  const expected = 'function'
-  const actual = typeof trigger
-
-  assert.equal(actual, expected, 'Trigger should be a function')
-  assert.end()
-})
-
-test('Track type', (assert) => {
-  const expected = 'function'
-  const actual = typeof track
-
-  assert.equal(actual, expected, 'Track should be a function')
-  assert.end()
-})

package/src/lib/reactivity/reactive.test.js

@@ -1,27 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import test from 'tape'
-import { reactive } from './reactive.js'
-
-test('Type', (assert) => {
-  const expected = 'function'
-  const actual = typeof reactive
-
-  assert.equal(actual, expected, 'Reactive should be a function')
-  assert.end()
-})