@poveste/app 0.18.3 → 0.19.1

package/src/__tests__/state-clone.spec.ts

@@ -1,120 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { markRaw, ref } from 'vue'
-import { toPresetState, toRawDeep } from '../app/util/state'
-
-/**
- * What the state-presets panel does to a variant's state before storing it.
- * `ComplexParameter.story.vue` builds both shapes this has to survive: a prop
- * holding a callback, and a pair of objects that reference each other.
- */
-const asPreset = (state: Record<string, any>) => toPresetState(state)
-
-function stateWithACallbackAndACycle() {
-  const parent: Record<string, any> = { name: 'hello' }
-  const child: Record<string, any> = {}
-  parent.child = child
-  child.parent = parent
-
-  return {
-    complexParameter: [{ action: () => {} }],
-    recursiveParameter: parent,
-    count: 1,
-  }
-}
-
-describe('a variant\'s state as a preset', () => {
-  it('is detached from the state it was taken from', () => {
-    const state = stateWithACallbackAndACycle()
-
-    const preset = asPreset(state)
-    state.recursiveParameter.name = 'edited'
-
-    expect(preset.recursiveParameter.name).toBe('hello')
-  })
-
-  it('keeps a self-referential prop as a cycle, which is what it is', () => {
-    const preset = asPreset(stateWithACallbackAndACycle())
-
-    expect(preset.recursiveParameter.child.parent).toBe(preset.recursiveParameter)
-  })
-
-  it('drops the callback, which no stored preset could carry anyway', () => {
-    const preset = asPreset(stateWithACallbackAndACycle())
-
-    expect(preset.complexParameter).toEqual([{}])
-  })
-
-  // The whole of the defect: the copy came out correct either way, but a story
-  // with a callback in its props logged a warning and an error on every mount.
-  it('does so without falling back, so nothing is logged at the reader', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const error = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-    asPreset(stateWithACallbackAndACycle())
-
-    expect(warn).not.toHaveBeenCalled()
-    expect(error).not.toHaveBeenCalled()
-    warn.mockRestore()
-    error.mockRestore()
-  })
-
-  it('still copies the ordinary values beside them', () => {
-    const preset = asPreset(stateWithACallbackAndACycle())
-
-    expect(preset.count).toBe(1)
-    expect(preset.recursiveParameter.name).toBe('hello')
-  })
-})
-
-describe('a binding Vue has marked raw', () => {
-  it('is dropped from what leaves the realm, rather than passed through', () => {
-    const graph = markRaw({ nodes: { deep: { deeper: 1 } } })
-
-    // `clean` means this copy is posted or persisted. `__v_skip` is
-    // non-enumerable and does not survive `structuredClone`, so passing the
-    // value would hand the far side an unmarked graph to deep-watch — which is
-    // the hanging story #957 describes. The key does not go.
-    expect(toRawDeep({ text: 'a', graph }, true)).toEqual({ text: 'a' })
-  })
-
-  it('is carried by reference when the copy stays in this realm', () => {
-    const graph = markRaw({ nodes: { deep: 1 } })
-    const copied = toRawDeep({ text: 'a', graph })
-
-    // Same identity, not a rebuilt one: that is what lets the compare settle it
-    // by `Object.is` instead of walking whatever is behind it.
-    expect(copied.graph).toBe(graph)
-    expect(copied.text).toBe('a')
-  })
-
-  it('is unwrapped from a ref first, which is the shape a template ref has', () => {
-    const graph = ref(markRaw({ nodes: { deep: 1 } }))
-
-    expect(toRawDeep({ graph }, true)).toEqual({})
-    expect(toRawDeep({ graph }).graph).toBe(graph.value)
-  })
-
-  it('leaves an array the way a function does', () => {
-    // Filtered, indices and all. Stated because it is a real consequence and
-    // not an obviously right one — it is the rule functions already follow.
-    expect(toRawDeep({ list: [1, markRaw({ a: 1 }), 2] }, true)).toEqual({ list: [1, 2] })
-  })
-
-  it('does not take the whole state with it when the state itself is marked', () => {
-    expect(toRawDeep(markRaw({ text: 'a' }), true)).toEqual({})
-  })
-
-  it('takes only itself when it sits inside an ordinary object', () => {
-    const state = { config: { zoom: 3, map: markRaw({ tiles: { deep: 1 } }) } }
-
-    // The far side keeps whatever it had under `config.map`, because a key that
-    // is not sent is a key `applyState` cannot overwrite — it merges one level.
-    expect(toRawDeep(state, true)).toEqual({ config: { zoom: 3 } })
-  })
-
-  it('never reaches a preset', () => {
-    const graph = markRaw({ nodes: { deep: 1 } })
-
-    expect(toPresetState({ count: 1, graph })).toEqual({ count: 1 })
-  })
-})

package/src/__tests__/state-types.spec.ts

@@ -1,175 +0,0 @@
-import { isEquivalent } from '@poveste/shared'
-import { describe, expect, it } from 'vitest'
-import { markRaw, reactive } from 'vue'
-import { toRawDeep } from '../app/util/state'
-
-/**
- * What the walker does to a value that is not a plain object.
- *
- * `postMessage` is structured clone, so structured clone is the boundary that
- * actually exists — and it carries `Date`, `Map`, `Set`, `RegExp`, `Error`,
- * typed arrays and `BigInt` intact. The walker flattened all of them to `{}`
- * before the transport was ever reached, so the question is not which types to
- * support but which ones we were destroying on the way (#977).
- */
-class Point {
-  constructor(public x: number, public y: number) {}
-  get len() { return Math.hypot(this.x, this.y) }
-}
-
-describe('a value the transport can carry', () => {
-  it('keeps a Date, rather than emptying it', () => {
-    const out = toRawDeep({ at: new Date(1790071200000) }, true)
-
-    expect(out.at).toBeInstanceOf(Date)
-    expect(out.at.getTime()).toBe(1790071200000)
-  })
-
-  it('keeps a Map and a Set with their contents', () => {
-    const out = toRawDeep({ m: new Map([['a', 1]]), s: new Set([1, 2, 3]) }, true)
-
-    expect(out.m).toBeInstanceOf(Map)
-    expect(out.m.get('a')).toBe(1)
-    expect(out.s).toBeInstanceOf(Set)
-    expect(out.s.size).toBe(3)
-  })
-
-  it('keeps a RegExp and an Error', () => {
-    const out = toRawDeep({ re: /ab+c/gi, err: new Error('boom') }, true)
-
-    expect(out.re).toBeInstanceOf(RegExp)
-    expect(out.re.source).toBe('ab+c')
-    expect(out.err).toBeInstanceOf(Error)
-    expect(out.err.message).toBe('boom')
-  })
-
-  it('keeps a typed array as one, rather than as an index map', () => {
-    const out = toRawDeep({ bytes: new Uint8Array([1, 2, 3]) }, true)
-
-    expect(out.bytes).toBeInstanceOf(Uint8Array)
-    expect([...out.bytes]).toEqual([1, 2, 3])
-  })
-
-  it('detaches it, so a later mutation does not reach the copy', () => {
-    const at = new Date(1790071200000)
-    const out = toRawDeep({ at }, true)
-
-    at.setTime(0)
-
-    expect(out.at.getTime()).toBe(1790071200000)
-  })
-})
-
-describe('a value the transport refuses', () => {
-  it('drops a URL rather than flattening it, the way a function is dropped', () => {
-    // Structured clone throws `DataCloneError` on a `URL`. Passing it through
-    // would turn a silent flattening into a thrown exception mid-sync, which is
-    // worse than what it replaces.
-    const out = toRawDeep({ href: new URL('https://poveste.dev/a'), kept: 1 }, true)
-
-    expect(Object.hasOwn(out, 'href')).toBe(false)
-    expect(out.kept).toBe(1)
-  })
-
-  it('leaves what it did send intact', () => {
-    const out = toRawDeep({ before: 1, href: new URL('https://poveste.dev/a'), after: 2 }, true)
-
-    expect(out).toEqual({ before: 1, after: 2 })
-  })
-})
-
-describe('a class instance', () => {
-  // Structured clone carries own fields and drops the prototype, so "faithful"
-  // has no meaning here. Plain is the answer, and it is now a stated one.
-  it('arrives as plain data, with its fields but not its accessors', () => {
-    const out = toRawDeep({ p: new Point(3, 4) }, true)
-
-    expect(out.p).toEqual({ x: 3, y: 4 })
-    expect(out.p.len).toBeUndefined()
-  })
-})
-
-describe('the two halves of the sync agree', () => {
-  // `isEquivalent` refuses to compare anything that is not a plain object,
-  // because "two distinct `Date`s would otherwise compare equal on an empty key
-  // list". That defence could not fire: it is handed the walker's output, and
-  // by then the `Date` was already `{}` (#977).
-  it('so two different dates are not equivalent after the walk', () => {
-    const a = toRawDeep({ at: new Date(1790071200000) }, true)
-    const b = toRawDeep({ at: new Date(0) }, true)
-
-    expect(isEquivalent(a, b)).toBe(false)
-  })
-
-  it('and the in-realm walk carries one by reference, which `Object.is` settles', () => {
-    const at = new Date(1790071200000)
-
-    expect(toRawDeep({ at }, false).at).toBe(at)
-  })
-})
-
-describe('a value that is reactive, which state always is', () => {
-  // The one that would have shipped a second silent failure. Vue proxies `Map`
-  // and `Set` but not `Date`, `RegExp`, `Error` or typed arrays, and
-  // `structuredClone` throws `DataCloneError` on the proxy while the raw
-  // object clones fine. Without `toRaw` a `Map` in reactive state is refused
-  // here and dropped — a different silence, not a fix for the first.
-  it('clones a reactive Map rather than refusing it', () => {
-    const state = reactive({ m: new Map([['a', 1]]) })
-
-    const out = toRawDeep(state, true)
-
-    expect(out.m).toBeInstanceOf(Map)
-    expect(out.m.get('a')).toBe(1)
-  })
-
-  it('clones a reactive Set the same way', () => {
-    const out = toRawDeep(reactive({ s: new Set([1, 2]) }), true)
-
-    expect(out.s).toBeInstanceOf(Set)
-    expect(out.s.size).toBe(2)
-  })
-
-  it('and a reactive Date, which Vue does not proxy', () => {
-    const out = toRawDeep(reactive({ at: new Date(1790071200000) }), true)
-
-    expect(out.at.getTime()).toBe(1790071200000)
-  })
-})
-
-describe('this walk\'s own rules reach inside a Map and a Set', () => {
-  // An array already comes out shorter for a function or a marked value. A
-  // container is the same problem, and answering it by refusing the whole
-  // `Map` would lose the keys beside it.
-  it('drops a function from a Map, and keeps the rest', () => {
-    const out = toRawDeep({ m: new Map<string, any>([['fn', () => {}], ['kept', 1]]) }, true)
-
-    expect(out.m.has('fn')).toBe(false)
-    expect(out.m.get('kept')).toBe(1)
-  })
-
-  it('drops a marked value from a Set, and keeps the rest', () => {
-    const out = toRawDeep({ s: new Set([markRaw({ heavy: true }), 'kept']) }, true)
-
-    expect([...out.s]).toEqual(['kept'])
-  })
-
-  it('survives a cycle that runs through a Map', () => {
-    const root: Record<string, any> = { name: 'root' }
-    root.m = new Map([['back', root]])
-
-    const out = toRawDeep(root, true)
-
-    expect(out.m.get('back')).toBe(out)
-  })
-})
-
-describe('identity inside one walk', () => {
-  it('gives one Date appearing twice the same copy, as the transport would', () => {
-    const at = new Date(1790071200000)
-
-    const out = toRawDeep({ a: at, b: at }, true)
-
-    expect(out.a).toBe(out.b)
-  })
-})

package/src/__tests__/uncaught.spec.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isBenignResizeObserverEvent } from '../app/util/uncaught'
-
-/**
- * The shape the sandbox's `error` listener sees. A browser-emitted
- * ResizeObserver notification carries a null `error`; a real throw carries the
- * `Error` that was thrown.
- */
-const notification = (message: string) => ({ error: null, message })
-const thrown = (message: string) => ({ error: new Error(message), message: `Uncaught Error: ${message}` })
-
-describe('a ResizeObserver loop notification', () => {
-  // Chrome's exact wording, trailing period included, as captured from a live
-  // observer loop.
-  it('is recognised as benign with the period Chrome sends', () => {
-    expect(isBenignResizeObserverEvent(notification('ResizeObserver loop completed with undelivered notifications.'))).toBe(true)
-  })
-
-  it('is recognised as benign without the period Firefox omits', () => {
-    expect(isBenignResizeObserverEvent(notification('ResizeObserver loop completed with undelivered notifications'))).toBe(true)
-  })
-
-  it('is recognised as benign in the older loop limit wording', () => {
-    expect(isBenignResizeObserverEvent(notification('ResizeObserver loop limit exceeded'))).toBe(true)
-  })
-})
-
-describe('an error the sandbox exists to report', () => {
-  it('is not treated as benign when a component throws the same text', () => {
-    expect(isBenignResizeObserverEvent(thrown('ResizeObserver loop completed with undelivered notifications'))).toBe(false)
-  })
-
-  it('is not treated as benign when an unrelated script fails with no error object', () => {
-    expect(isBenignResizeObserverEvent(notification('Script error.'))).toBe(false)
-  })
-})