10337108635

Committed 11 Aug 2024 04:48AM UTC coverage: 91.54% (+0.02%) from 91.522%

Build # 10337108635

Build Type

push

github

Committed by

web-flow

Commit Message

atom.io/strongly ordered keys (#2384)

Run Details

1443 of 1563 branches covered (92.32%)

Branch coverage included in aggregate %.

30 of 31 new or added lines in 22 files covered. (96.77%)

3 existing lines in 1 file now uncovered.

8133 of 8898 relevant lines covered (91.4%)

1512.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.86

/packages/atom.io/react-devtools/src/StateIndex.tsx

import type {
        ReadableToken,
        ReadonlySelectorToken,
        RegularAtomToken,
} from "atom.io"
import { getState, selectorFamily } from "atom.io"
import { findState } from "atom.io/ephemeral"
import type { FamilyNode, WritableTokenIndex } from "atom.io/introspection"
import type { Canonical } from "atom.io/json"
import { useI, useO } from "atom.io/react"
import type { FC } from "react"

import { isJson, refineJsonType } from "~/packages/anvl/src/refinement"

import { findViewIsOpenState, primitiveRefinery } from "."
import { button } from "./Button"
import { StoreEditor } from "./StateEditor"

const findStateTypeState = selectorFamily<string, Canonical>({
        key: `👁‍🗨 State Type`,
        get:
                (token) =>
                ({ get }) => {
                        let state: unknown
                        try {
                                state = get(token as any)
                        } catch (error) {
                                return `error`
                        }
                        if (state === undefined) return `undefined`
                        if (isJson(state)) return refineJsonType(state).type
                        return Object.getPrototypeOf(state).constructor.name
                },
})

export const StateIndexLeafNode: FC<{
        node: ReadableToken<unknown>
        isOpenState: RegularAtomToken<boolean>
        typeState: ReadonlySelectorToken<string>
}> = ({ node, isOpenState, typeState }) => {
        const setIsOpen = useI(isOpenState)
        const isOpen = useO(isOpenState)

        const state = useO(node)
        const stateType = useO(typeState)

        const isPrimitive = Boolean(primitiveRefinery.refine(state))

        return (
                <>
                        <header>
                                <button.OpenClose
                                        isOpen={isOpen && !isPrimitive}
                                        testid={`open-close-state-${node.key}`}
                                        setIsOpen={setIsOpen}
                                        disabled={isPrimitive}
                                />
                                <label
                                        onClick={() => {
                                                console.log(node, getState(node))
                                        }}
                                        onKeyUp={() => {
                                                console.log(node, getState(node))
                                        }}
                                >
                                        <h2>{node.family?.subKey ?? node.key}</h2>
                                        <span className="type detail">({stateType})</span>
                                </label>
                                <StoreEditor token={node} />
                        </header>
                        {isOpen && !isPrimitive ? (
                                <main>
                                        <StoreEditor token={node} />
                                </main>
                        ) : null}
                </>
        )
}
export const StateIndexTreeNode: FC<{
        node: FamilyNode<ReadableToken<unknown>>
        isOpenState: RegularAtomToken<boolean>
}> = ({ node, isOpenState }) => {
        const setIsOpen = useI(isOpenState)
        const isOpen = useO(isOpenState)
        for (const [key, childNode] of node.familyMembers) {
                findState(findViewIsOpenState, key)
                findState(findStateTypeState, childNode.key)
        }
        return (
                <>
                        <header>
                                <button.OpenClose
                                        isOpen={isOpen}
                                        testid={`open-close-state-family-${node.key}`}
                                        setIsOpen={setIsOpen}
                                />
                                <label>
                                        <h2>{node.key}</h2>
                                        <span className="type detail"> (family)</span>
                                </label>
                        </header>
                        {isOpen
                                ? [...node.familyMembers.entries()].map(([key, childNode]) => (
                                                <StateIndexNode
                                                        key={key}
                                                        node={childNode}
                                                        isOpenState={findState(findViewIsOpenState, childNode.key)}
                                                        typeState={findState(findStateTypeState, childNode.key)}
                                                />
                                        ))
                                : null}
                </>
        )
}

export const StateIndexNode: FC<{
        node: FamilyNode<ReadableToken<unknown>> | ReadableToken<unknown>
        isOpenState: RegularAtomToken<boolean>
        typeState: ReadonlySelectorToken<string>
}> = ({ node, isOpenState, typeState }) => {
        return (
                <section className="node state" data-testid={`state-${node.key}`}>
                        {`type` in node ? (
                                <StateIndexLeafNode
                                        node={node}
                                        isOpenState={isOpenState}
                                        typeState={typeState}
                                />
                        ) : (
                                <StateIndexTreeNode node={node} isOpenState={isOpenState} />
                        )}
                </section>
        )
}

export const StateIndex: FC<{
        tokenIndex: ReadonlySelectorToken<WritableTokenIndex<ReadableToken<unknown>>>
}> = ({ tokenIndex }) => {
        const tokenIds = useO(tokenIndex)
        return (
                <article className="index state_index" data-testid="state-index">
                        {[...tokenIds.entries()]
                                .filter(([key]) => !key.startsWith(`👁‍🗨`))
                                .sort()
                                .map(([key, node]) => {
                                        return (
                                                <StateIndexNode
                                                        key={key}
                                                        node={node}
                                                        isOpenState={findState(findViewIsOpenState, node.key)}
                                                        typeState={findState(findStateTypeState, node.key)}
                                                />
                                        )
                                })}
                </article>
        )
}

1	import type {	1✔
2	ReadableToken,
3	ReadonlySelectorToken,
4	RegularAtomToken,
5	} from "atom.io"
6	import { getState, selectorFamily } from "atom.io"	1✔
7	import { findState } from "atom.io/ephemeral"	1✔
8	import type { FamilyNode, WritableTokenIndex } from "atom.io/introspection"
9	import type { Canonical } from "atom.io/json"
10	import { useI, useO } from "atom.io/react"	1✔
11	import type { FC } from "react"
12
13	import { isJson, refineJsonType } from "~/packages/anvl/src/refinement"	1✔
14
15	import { findViewIsOpenState, primitiveRefinery } from "."	1✔
16	import { button } from "./Button"	1✔
17	import { StoreEditor } from "./StateEditor"	1✔
18
19	const findStateTypeState = selectorFamily<string, Canonical>({	1✔
20	key: `👁‍🗨 State Type`,	1✔
21	get:	1✔
22	(token) =>	1✔
23	({ get }) => {	7✔
24	let state: unknown	7✔
25	try {	7✔
26	state = get(token as any)	7✔
27	} catch (error) {	7✔
28	return `error`	7✔
29	}	7!
UNCOV 30	if (state === undefined) return `undefined`	×
UNCOV 31	if (isJson(state)) return refineJsonType(state).type	×
UNCOV 32	return Object.getPrototypeOf(state).constructor.name	×
33	},	7✔
34	})	1✔
35
36	export const StateIndexLeafNode: FC<{	1✔
37	node: ReadableToken<unknown>
38	isOpenState: RegularAtomToken<boolean>
39	typeState: ReadonlySelectorToken<string>
40	}> = ({ node, isOpenState, typeState }) => {	1✔
41	const setIsOpen = useI(isOpenState)	6✔
42	const isOpen = useO(isOpenState)	6✔
43
44	const state = useO(node)	6✔
45	const stateType = useO(typeState)	6✔
46
47	const isPrimitive = Boolean(primitiveRefinery.refine(state))	6✔
48
49	return (	6✔
50	<>	6✔
51	<header>	6✔
52	<button.OpenClose	6✔
53	isOpen={isOpen && !isPrimitive}	6!
54	testid={`open-close-state-${node.key}`}	6✔
55	setIsOpen={setIsOpen}	6✔
56	disabled={isPrimitive}	6✔
57	/>	6✔
58	<label	6✔
59	onClick={() => {	6✔
60	console.log(node, getState(node))	×
61	}}	×
62	onKeyUp={() => {	6✔
63	console.log(node, getState(node))	×
64	}}	×
65	>
66	<h2>{node.family?.subKey ?? node.key}</h2>	6!
67	<span className="type detail">({stateType})</span>	6✔
68	</label>	6✔
69	<StoreEditor token={node} />	6✔
70	</header>	6✔
71	{isOpen && !isPrimitive ? (	6!
72	<main>	×
73	<StoreEditor token={node} />	×
74	</main>	×
75	) : null}	6✔
76	</>	6✔
77	)
78	}	6✔
79	export const StateIndexTreeNode: FC<{	1✔
80	node: FamilyNode<ReadableToken<unknown>>
81	isOpenState: RegularAtomToken<boolean>
82	}> = ({ node, isOpenState }) => {	1✔
83	const setIsOpen = useI(isOpenState)	1✔
84	const isOpen = useO(isOpenState)	1✔
85	for (const [key, childNode] of node.familyMembers) {	1✔
86	findState(findViewIsOpenState, key)	1✔
87	findState(findStateTypeState, childNode.key)	1✔
88	}	1✔
89	return (	1✔
90	<>	1✔
91	<header>	1✔
92	<button.OpenClose	1✔
93	isOpen={isOpen}	1✔
94	testid={`open-close-state-family-${node.key}`}	1✔
95	setIsOpen={setIsOpen}	1✔
96	/>	1✔
97	<label>	1✔
98	<h2>{node.key}</h2>	1✔
99	<span className="type detail"> (family)</span>	1✔
100	</label>	1✔
101	</header>	1✔
102	{isOpen	1!
103	? [...node.familyMembers.entries()].map(([key, childNode]) => (	×
104	<StateIndexNode	×
105	key={key}	×
106	node={childNode}	×
107	isOpenState={findState(findViewIsOpenState, childNode.key)}	×
NEW 108	typeState={findState(findStateTypeState, childNode.key)}	×
109	/>	×
110	))	×
111	: null}	1✔
112	</>	1✔
113	)
114	}	1✔
115
116	export const StateIndexNode: FC<{	1✔
117	node: FamilyNode<ReadableToken<unknown>> \| ReadableToken<unknown>
118	isOpenState: RegularAtomToken<boolean>
119	typeState: ReadonlySelectorToken<string>
120	}> = ({ node, isOpenState, typeState }) => {	1✔
121	return (	6✔
122	<section className="node state" data-testid={`state-${node.key}`}>	6✔
123	{`type` in node ? (	6✔
124	<StateIndexLeafNode	5✔
125	node={node}	5✔
126	isOpenState={isOpenState}	5✔
127	typeState={typeState}	5✔
128	/>	5✔
129	) : (
130	<StateIndexTreeNode node={node} isOpenState={isOpenState} />	1✔
131	)}
132	</section>	6✔
133	)
134	}	6✔
135
136	export const StateIndex: FC<{	1✔
137	tokenIndex: ReadonlySelectorToken<WritableTokenIndex<ReadableToken<unknown>>>
138	}> = ({ tokenIndex }) => {	1✔
139	const tokenIds = useO(tokenIndex)	2✔
140	return (	2✔
141	<article className="index state_index" data-testid="state-index">	2✔
142	{[...tokenIds.entries()]	2✔
143	.filter(([key]) => !key.startsWith(`👁‍🗨`))	2✔
144	.sort()	2✔
145	.map(([key, node]) => {	2✔
146	return (	6✔
147	<StateIndexNode	6✔
148	key={key}	6✔
149	node={node}	6✔
150	isOpenState={findState(findViewIsOpenState, node.key)}	6✔
151	typeState={findState(findStateTypeState, node.key)}	6✔
152	/>	6✔
153	)
154	})}	2✔
155	</article>	2✔
156	)
157	}	2✔

jeremybanka / wayforge / 10337108635

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous