@cratis/scene.primereact 4.6.0 → 4.8.0

package/dist/cjs/data/selectionKeysOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionKeysOf.js","sources":["../../../data/selectionKeysOf.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** The keys of one node, whichever of the shapes a selection may use. */\nfunction keyOf(value: unknown): string | undefined {\n    if (typeof value === 'string' && value !== '') return value;\n    return typeof value === 'number' && Number.isFinite(value) ? String(value) : undefined;\n}\n\nfunction nodeKeyOf(value: unknown): string | undefined {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) return keyOf(value);\n    return keyOf((value as { key?: unknown }).key);\n}\n\n/**\n * Reads the keys an authored `selection` selects.\n *\n * Every shape a legacy document may hold is accepted, and none is rewritten:\n * - one key, string or number (`'b'`, `6`);\n * - an array mixing keys and `{ key }` objects (`['a', 6, { key: 'c' }]`);\n * - one `{ key }` object;\n * - PrimeReact's key map (`{ b: { checked: true, partialChecked: false } }`), whose `checked` entries are\n *   selected. A `partialChecked` entry is derived state, not a selection, so it is ignored: the control\n *   computes it from the selected descendants.\n *\n * Numeric keys are matched as the strings the tree builds from them.\n *\n * @param value The authored selection.\n */\nexport function selectionKeysOf(value: unknown): Set<string> {\n    if (Array.isArray(value)) return new Set(value.flatMap(entry => nodeKeyOf(entry) ?? []));\n    const single = nodeKeyOf(value);\n    if (single !== undefined) return new Set([single]);\n\n    if (typeof value === 'object' && value !== null && keyOf((value as { key?: unknown }).key) === undefined) {\n        return new Set(Object.entries(value).filter(([, state]) => (state as { checked?: unknown } | null)?.checked === true).map(([key]) => key));\n    }\n\n    return new Set();\n}\n"],"names":["keyOf","value","Number","isFinite","String","undefined","nodeKeyOf","Array","isArray","key","selectionKeysOf","Set","flatMap","entry","single","Object","entries","filter","state","checked","map"],"mappings":";;AAAA;AACA;AAEA,0EACA,SAASA,KAAAA,CAAMC,KAAc,EAAA;AACzB,IAAA,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAI,OAAOA,KAAAA;IACtD,OAAO,OAAOA,UAAU,QAAA,IAAYC,MAAAA,CAAOC,QAAQ,CAACF,KAAAA,CAAAA,GAASG,OAAOH,KAAAA,CAAAA,GAASI,SAAAA;AACjF;AAEA,SAASC,UAAUL,KAAc,EAAA;IAC7B,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQM,MAAMC,OAAO,CAACP,KAAAA,CAAAA,EAAQ,OAAOD,KAAAA,CAAMC,KAAAA,CAAAA;IACtF,OAAOD,KAAAA,CAAM,KAACC,CAA4BQ,GAAG,CAAA;AACjD;AAEA;;;;;;;;;;;;;;IAeO,SAASC,eAAAA,CAAgBT,KAAc,EAAA;AAC1C,IAAA,IAAIM,KAAAA,CAAMC,OAAO,CAACP,KAAAA,CAAAA,EAAQ,OAAO,IAAIU,GAAAA,CAAIV,KAAAA,CAAMW,OAAO,CAACC,CAAAA,KAAAA,GAASP,SAAAA,CAAUO,UAAU,EAAE,CAAA,CAAA;AACtF,IAAA,MAAMC,SAASR,SAAAA,CAAUL,KAAAA,CAAAA;AACzB,IAAA,IAAIa,MAAAA,KAAWT,SAAAA,EAAW,OAAO,IAAIM,GAAAA,CAAI;AAACG,QAAAA;AAAO,KAAA,CAAA;IAEjD,IAAI,OAAOb,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQD,MAAM,KAACC,CAA4BQ,GAAG,CAAA,KAAMJ,SAAAA,EAAW;QACtG,OAAO,IAAIM,IAAII,MAAAA,CAAOC,OAAO,CAACf,KAAAA,CAAAA,CAAOgB,MAAM,CAAC,CAAC,GAAGC,MAAM,GAAMA,OAAwCC,OAAAA,KAAY,IAAA,CAAA,CAAMC,GAAG,CAAC,CAAC,CAACX,GAAAA,CAAI,GAAKA,GAAAA,CAAAA,CAAAA;AACzI,IAAA;AAEA,IAAA,OAAO,IAAIE,GAAAA,EAAAA;AACf;;"}

package/dist/cjs/data/treeTableRows.js

@@ -0,0 +1,42 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Flattens the nodes into the rows that are visible: a node's children follow it only while it is expanded.
+ *
+ * @param nodes The sibling nodes to flatten.
+ * @param expanded The keys of the expanded nodes.
+ */ function visibleRows(nodes, expanded, depth = 0, parentKey) {
+    return nodes.flatMap((node, index)=>{
+        const key = node.key ?? '';
+        const row = {
+            node,
+            key,
+            depth,
+            parentKey,
+            position: index + 1,
+            siblings: nodes.length
+        };
+        return [
+            row,
+            ...node.children !== undefined && expanded.has(key) ? visibleRows(node.children, expanded, depth + 1, key) : []
+        ];
+    });
+}
+/** The keys of the nodes authored as expanded, at any depth, in tree order. */ function expandedKeysOf(nodes) {
+    return nodes.flatMap((node)=>[
+            ...node.expanded === true && node.key !== undefined ? [
+                node.key
+            ] : [],
+            ...expandedKeysOf(node.children ?? [])
+        ]);
+}
+/** A node's own text for naming it: its label, else its key. */ function nodeLabel(node) {
+    return node.label ?? node.key ?? '';
+}
+
+exports.expandedKeysOf = expandedKeysOf;
+exports.nodeLabel = nodeLabel;
+exports.visibleRows = visibleRows;
+//# sourceMappingURL=treeTableRows.js.map

package/dist/cjs/data/treeTableRows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeTableRows.js","sources":["../../../data/treeTableRows.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { TreeNode } from '../TreeNode';\nimport { TreeTableRow } from './TreeTableRow';\n\n/**\n * Flattens the nodes into the rows that are visible: a node's children follow it only while it is expanded.\n *\n * @param nodes The sibling nodes to flatten.\n * @param expanded The keys of the expanded nodes.\n */\nexport function visibleRows(nodes: TreeNode[], expanded: ReadonlySet<string>, depth = 0, parentKey?: string): TreeTableRow[] {\n    return nodes.flatMap((node, index) => {\n        const key = node.key ?? '';\n        const row: TreeTableRow = { node, key, depth, parentKey, position: index + 1, siblings: nodes.length };\n        return [row, ...(node.children !== undefined && expanded.has(key) ? visibleRows(node.children, expanded, depth + 1, key) : [])];\n    });\n}\n\n/** The keys of the nodes authored as expanded, at any depth, in tree order. */\nexport function expandedKeysOf(nodes: TreeNode[]): string[] {\n    return nodes.flatMap(node => [\n        ...(node.expanded === true && node.key !== undefined ? [node.key] : []),\n        ...expandedKeysOf(node.children ?? []),\n    ]);\n}\n\n/** A node's own text for naming it: its label, else its key. */\nexport function nodeLabel(node: TreeNode): string {\n    return node.label ?? node.key ?? '';\n}\n"],"names":["visibleRows","nodes","expanded","depth","parentKey","flatMap","node","index","key","row","position","siblings","length","children","undefined","has","expandedKeysOf","nodeLabel","label"],"mappings":";;AAAA;AACA;AAKA;;;;;IAMO,SAASA,WAAAA,CAAYC,KAAiB,EAAEC,QAA6B,EAAEC,KAAAA,GAAQ,CAAC,EAAEC,SAAkB,EAAA;AACvG,IAAA,OAAOH,KAAAA,CAAMI,OAAO,CAAC,CAACC,IAAAA,EAAMC,KAAAA,GAAAA;QACxB,MAAMC,GAAAA,GAAMF,IAAAA,CAAKE,GAAG,IAAI,EAAA;AACxB,QAAA,MAAMC,GAAAA,GAAoB;AAAEH,YAAAA,IAAAA;AAAME,YAAAA,GAAAA;AAAKL,YAAAA,KAAAA;AAAOC,YAAAA,SAAAA;AAAWM,YAAAA,QAAAA,EAAUH,KAAAA,GAAQ,CAAA;AAAGI,YAAAA,QAAAA,EAAUV,MAAMW;AAAO,SAAA;QACrG,OAAO;AAACH,YAAAA,GAAAA;AAASH,YAAAA,GAAAA,IAAAA,CAAKO,QAAQ,KAAKC,SAAAA,IAAaZ,QAAAA,CAASa,GAAG,CAACP,GAAAA,CAAAA,GAAOR,WAAAA,CAAYM,IAAAA,CAAKO,QAAQ,EAAEX,QAAAA,EAAUC,KAAAA,GAAQ,CAAA,EAAGK,OAAO;AAAI,SAAA;AACnI,IAAA,CAAA,CAAA;AACJ;AAEA,gFACO,SAASQ,cAAAA,CAAef,KAAiB,EAAA;AAC5C,IAAA,OAAOA,KAAAA,CAAMI,OAAO,CAACC,CAAAA,IAAAA,GAAQ;AACrBA,YAAAA,GAAAA,IAAAA,CAAKJ,QAAQ,KAAK,IAAA,IAAQI,IAAAA,CAAKE,GAAG,KAAKM,SAAAA,GAAY;AAACR,gBAAAA,IAAAA,CAAKE;AAAI,aAAA,GAAG,EAAE;eACnEQ,cAAAA,CAAeV,IAAAA,CAAKO,QAAQ,IAAI,EAAE;AACxC,SAAA,CAAA;AACL;AAEA,iEACO,SAASI,SAAAA,CAAUX,IAAc,EAAA;AACpC,IAAA,OAAOA,IAAAA,CAAKY,KAAK,IAAIZ,IAAAA,CAAKE,GAAG,IAAI,EAAA;AACrC;;;;"}

package/dist/cjs/data/useIncrementalLoad.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var react = require('react');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Tracks how many entries of a list are loaded, a chunk at a time.
+ *
+ * The count follows the authored properties: it starts over at one chunk when the chunk size changes or when
+ * `resetKey` does, so a document edit that replaces the items does not leave the old count behind. Pass a
+ * structurally stable `resetKey` (see `useStructuralValue`), or every render would reset it.
+ *
+ * @param total The number of entries there are.
+ * @param chunk The number of entries per load.
+ * @param resetKey Changes when the entries are replaced.
+ */ function useIncrementalLoad(total, chunk, resetKey) {
+    const [state, setState] = react.useState({
+        resetKey,
+        chunk,
+        loaded: chunk
+    });
+    let loaded = state.loaded;
+    if (state.resetKey !== resetKey || state.chunk !== chunk) {
+        setState({
+            resetKey,
+            chunk,
+            loaded: chunk
+        });
+        loaded = chunk;
+    }
+    const loadMore = react.useCallback(()=>setState((current)=>({
+                ...current,
+                loaded: Math.min(current.loaded + chunk, total)
+            })), [
+        chunk,
+        total
+    ]);
+    return {
+        loaded: Math.min(loaded, total),
+        loadMore
+    };
+}
+
+exports.useIncrementalLoad = useIncrementalLoad;
+//# sourceMappingURL=useIncrementalLoad.js.map

package/dist/cjs/data/useIncrementalLoad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIncrementalLoad.js","sources":["../../../data/useIncrementalLoad.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useCallback, useState } from 'react';\n\n/** How much of a list is loaded and how to load more. */\nexport interface IncrementalLoad {\n    /** The number of entries loaded, never more than the total. */\n    loaded: number;\n\n    /** Loads the next chunk. */\n    loadMore(): void;\n}\n\n/**\n * Tracks how many entries of a list are loaded, a chunk at a time.\n *\n * The count follows the authored properties: it starts over at one chunk when the chunk size changes or when\n * `resetKey` does, so a document edit that replaces the items does not leave the old count behind. Pass a\n * structurally stable `resetKey` (see `useStructuralValue`), or every render would reset it.\n *\n * @param total The number of entries there are.\n * @param chunk The number of entries per load.\n * @param resetKey Changes when the entries are replaced.\n */\nexport function useIncrementalLoad(total: number, chunk: number, resetKey: unknown): IncrementalLoad {\n    const [state, setState] = useState({ resetKey, chunk, loaded: chunk });\n    let loaded = state.loaded;\n    if (state.resetKey !== resetKey || state.chunk !== chunk) {\n        setState({ resetKey, chunk, loaded: chunk });\n        loaded = chunk;\n    }\n\n    const loadMore = useCallback(() => setState(current => ({ ...current, loaded: Math.min(current.loaded + chunk, total) })), [chunk, total]);\n    return { loaded: Math.min(loaded, total), loadMore };\n}\n"],"names":["useIncrementalLoad","total","chunk","resetKey","state","setState","useState","loaded","loadMore","useCallback","current","Math","min"],"mappings":";;;;AAAA;AACA;AAaA;;;;;;;;;;AAUC,IACM,SAASA,kBAAAA,CAAmBC,KAAa,EAAEC,KAAa,EAAEC,QAAiB,EAAA;AAC9E,IAAA,MAAM,CAACC,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAAS;AAAEH,QAAAA,QAAAA;AAAUD,QAAAA,KAAAA;QAAOK,MAAAA,EAAQL;AAAM,KAAA,CAAA;IACpE,IAAIK,MAAAA,GAASH,MAAMG,MAAM;AACzB,IAAA,IAAIH,MAAMD,QAAQ,KAAKA,YAAYC,KAAAA,CAAMF,KAAK,KAAKA,KAAAA,EAAO;QACtDG,QAAAA,CAAS;AAAEF,YAAAA,QAAAA;AAAUD,YAAAA,KAAAA;YAAOK,MAAAA,EAAQL;AAAM,SAAA,CAAA;QAC1CK,MAAAA,GAASL,KAAAA;AACb,IAAA;AAEA,IAAA,MAAMM,WAAWC,iBAAAA,CAAY,IAAMJ,QAAAA,CAASK,CAAAA,WAAY;AAAE,gBAAA,GAAGA,OAAO;AAAEH,gBAAAA,MAAAA,EAAQI,KAAKC,GAAG,CAACF,OAAAA,CAAQH,MAAM,GAAGL,KAAAA,EAAOD,KAAAA;AAAO,aAAA,CAAA,CAAA,EAAK;AAACC,QAAAA,KAAAA;AAAOD,QAAAA;AAAM,KAAA,CAAA;IACzI,OAAO;QAAEM,MAAAA,EAAQI,IAAAA,CAAKC,GAAG,CAACL,MAAAA,EAAQN,KAAAA,CAAAA;AAAQO,QAAAA;AAAS,KAAA;AACvD;;"}

package/dist/cjs/data/useLoadOnReach.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var react = require('react');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Calls `onReach` while the sentinel is visible, which is what scrolling to the end of a list means.
+ *
+ * The observer is rebuilt whenever `revision` changes, so a sentinel that is still visible after a chunk was
+ * loaded loads the next one, until the viewport is filled or the list ends. `root` is the element that
+ * scrolls for an inline list; `null` observes the page's own viewport. Where there is no
+ * `IntersectionObserver` nothing is observed and the list's own button remains the way to load more.
+ *
+ * @param sentinel The element placed after the last loaded entry.
+ * @param root The scrolling container, or `null` for the page.
+ * @param active Whether reaching the end should load anything.
+ * @param revision A value that changes each time the list changed.
+ * @param onReach Loads the next chunk.
+ */ function useLoadOnReach(sentinel, root, active, revision, onReach) {
+    react.useEffect(()=>{
+        const target = sentinel.current;
+        if (!active || target === null || typeof IntersectionObserver === 'undefined') return undefined;
+        const observer = new IntersectionObserver((entries)=>{
+            if (entries.some((entry)=>entry.isIntersecting)) onReach();
+        }, {
+            root: root?.current ?? null,
+            rootMargin: '0px 0px 48px 0px'
+        });
+        observer.observe(target);
+        return ()=>observer.disconnect();
+    }, [
+        sentinel,
+        root,
+        active,
+        revision,
+        onReach
+    ]);
+}
+
+exports.useLoadOnReach = useLoadOnReach;
+//# sourceMappingURL=useLoadOnReach.js.map

package/dist/cjs/data/useLoadOnReach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadOnReach.js","sources":["../../../data/useLoadOnReach.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { RefObject, useEffect } from 'react';\n\n/**\n * Calls `onReach` while the sentinel is visible, which is what scrolling to the end of a list means.\n *\n * The observer is rebuilt whenever `revision` changes, so a sentinel that is still visible after a chunk was\n * loaded loads the next one, until the viewport is filled or the list ends. `root` is the element that\n * scrolls for an inline list; `null` observes the page's own viewport. Where there is no\n * `IntersectionObserver` nothing is observed and the list's own button remains the way to load more.\n *\n * @param sentinel The element placed after the last loaded entry.\n * @param root The scrolling container, or `null` for the page.\n * @param active Whether reaching the end should load anything.\n * @param revision A value that changes each time the list changed.\n * @param onReach Loads the next chunk.\n */\nexport function useLoadOnReach(sentinel: RefObject<HTMLElement | null>, root: RefObject<HTMLElement | null> | null, active: boolean, revision: unknown, onReach: () => void): void {\n    useEffect(() => {\n        const target = sentinel.current;\n        if (!active || target === null || typeof IntersectionObserver === 'undefined') return undefined;\n\n        const observer = new IntersectionObserver(entries => {\n            if (entries.some(entry => entry.isIntersecting)) onReach();\n        }, { root: root?.current ?? null, rootMargin: '0px 0px 48px 0px' });\n        observer.observe(target);\n        return () => observer.disconnect();\n    }, [sentinel, root, active, revision, onReach]);\n}\n"],"names":["useLoadOnReach","sentinel","root","active","revision","onReach","useEffect","target","current","IntersectionObserver","undefined","observer","entries","some","entry","isIntersecting","rootMargin","observe","disconnect"],"mappings":";;;;AAAA;AACA;AAIA;;;;;;;;;;;;;IAcO,SAASA,cAAAA,CAAeC,QAAuC,EAAEC,IAA0C,EAAEC,MAAe,EAAEC,QAAiB,EAAEC,OAAmB,EAAA;IACvKC,eAAAA,CAAU,IAAA;QACN,MAAMC,MAAAA,GAASN,SAASO,OAAO;AAC/B,QAAA,IAAI,CAACL,MAAAA,IAAUI,MAAAA,KAAW,QAAQ,OAAOE,oBAAAA,KAAyB,aAAa,OAAOC,SAAAA;QAEtF,MAAMC,QAAAA,GAAW,IAAIF,oBAAAA,CAAqBG,CAAAA,OAAAA,GAAAA;AACtC,YAAA,IAAIA,QAAQC,IAAI,CAACC,CAAAA,KAAAA,GAASA,KAAAA,CAAMC,cAAc,CAAA,EAAGV,OAAAA,EAAAA;QACrD,CAAA,EAAG;AAAEH,YAAAA,IAAAA,EAAMA,MAAMM,OAAAA,IAAW,IAAA;YAAMQ,UAAAA,EAAY;AAAmB,SAAA,CAAA;AACjEL,QAAAA,QAAAA,CAASM,OAAO,CAACV,MAAAA,CAAAA;QACjB,OAAO,IAAMI,SAASO,UAAU,EAAA;IACpC,CAAA,EAAG;AAACjB,QAAAA,QAAAA;AAAUC,QAAAA,IAAAA;AAAMC,QAAAA,MAAAA;AAAQC,QAAAA,QAAAA;AAAUC,QAAAA;AAAQ,KAAA,CAAA;AAClD;;"}

package/dist/cjs/data/useTreeGridNavigation.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var react = require('react');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The keyboard model of an ARIA tree grid, with a roving tab index.
+ *
+ * Up and Down move between visible rows, Home and End to the first and last, Right expands a collapsed row or
+ * enters its first child, Left collapses an expanded row or goes to its parent, and Space or Enter selects.
+ * Keys pressed on a control inside the row (its expand button or checkbox) are left to that control.
+ */ function useTreeGridNavigation({ rows, expanded, enabled, toggle, select }) {
+    const [activeKey, setActiveKey] = react.useState(undefined);
+    const elements = react.useRef(new Map());
+    const tabStopKey = rows.some((row)=>row.key === activeKey) ? activeKey : rows[0]?.key;
+    const register = react.useCallback((key, element)=>{
+        if (element === null) elements.current.delete(key);
+        else elements.current.set(key, element);
+    }, []);
+    const moveTo = (row)=>{
+        if (row === undefined) return;
+        setActiveKey(row.key);
+        elements.current.get(row.key)?.focus();
+    };
+    const onKeyDown = (row, event)=>{
+        if (event.target !== event.currentTarget) return;
+        const index = rows.indexOf(row);
+        const hasChildren = (row.node.children?.length ?? 0) > 0;
+        const handled = (action)=>{
+            event.preventDefault();
+            action();
+        };
+        switch(event.key){
+            case 'ArrowDown':
+                handled(()=>moveTo(rows[index + 1]));
+                break;
+            case 'ArrowUp':
+                handled(()=>moveTo(rows[index - 1]));
+                break;
+            case 'Home':
+                handled(()=>moveTo(rows[0]));
+                break;
+            case 'End':
+                handled(()=>moveTo(rows[rows.length - 1]));
+                break;
+            case 'ArrowRight':
+                if (hasChildren) handled(()=>{
+                    if (!expanded.has(row.key)) {
+                        if (enabled) toggle(row.key);
+                    } else moveTo(rows[index + 1]);
+                });
+                break;
+            case 'ArrowLeft':
+                if (hasChildren && expanded.has(row.key)) handled(()=>{
+                    if (enabled) toggle(row.key);
+                });
+                else if (row.parentKey !== undefined) handled(()=>moveTo(rows.find((candidate)=>candidate.key === row.parentKey)));
+                break;
+            case ' ':
+            case 'Enter':
+                handled(()=>select(row));
+                break;
+        }
+    };
+    return {
+        tabStopKey,
+        register,
+        activate: setActiveKey,
+        onKeyDown
+    };
+}
+
+exports.useTreeGridNavigation = useTreeGridNavigation;
+//# sourceMappingURL=useTreeGridNavigation.js.map

package/dist/cjs/data/useTreeGridNavigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeGridNavigation.js","sources":["../../../data/useTreeGridNavigation.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { KeyboardEvent, useCallback, useRef, useState } from 'react';\nimport { TreeTableRow } from './TreeTableRow';\n\n/** What the keyboard navigation of a tree grid needs from the control. */\nexport interface TreeGridNavigationOptions {\n    rows: TreeTableRow[];\n    expanded: ReadonlySet<string>;\n    enabled: boolean;\n    toggle(key: string): void;\n    select(row: TreeTableRow): void;\n}\n\n/** The wiring a tree grid applies to its rows. */\nexport interface TreeGridNavigation {\n    /** The one row that is in the tab order (roving tabindex). */\n    tabStopKey: string | undefined;\n\n    /** Gives the navigation the element of a row, so it can move focus there. */\n    register(key: string, element: HTMLElement | null): void;\n\n    /** Makes a row the tab stop, as a click does. */\n    activate(key: string): void;\n\n    /** The key handler of a row. */\n    onKeyDown(row: TreeTableRow, event: KeyboardEvent<HTMLElement>): void;\n}\n\n/**\n * The keyboard model of an ARIA tree grid, with a roving tab index.\n *\n * Up and Down move between visible rows, Home and End to the first and last, Right expands a collapsed row or\n * enters its first child, Left collapses an expanded row or goes to its parent, and Space or Enter selects.\n * Keys pressed on a control inside the row (its expand button or checkbox) are left to that control.\n */\nexport function useTreeGridNavigation({ rows, expanded, enabled, toggle, select }: TreeGridNavigationOptions): TreeGridNavigation {\n    const [activeKey, setActiveKey] = useState<string | undefined>(undefined);\n    const elements = useRef(new Map<string, HTMLElement>());\n    const tabStopKey = rows.some(row => row.key === activeKey) ? activeKey : rows[0]?.key;\n\n    const register = useCallback((key: string, element: HTMLElement | null) => {\n        if (element === null) elements.current.delete(key); else elements.current.set(key, element);\n    }, []);\n\n    const moveTo = (row: TreeTableRow | undefined) => {\n        if (row === undefined) return;\n        setActiveKey(row.key);\n        elements.current.get(row.key)?.focus();\n    };\n\n    const onKeyDown = (row: TreeTableRow, event: KeyboardEvent<HTMLElement>) => {\n        if (event.target !== event.currentTarget) return;\n        const index = rows.indexOf(row);\n        const hasChildren = (row.node.children?.length ?? 0) > 0;\n        const handled = (action: () => void) => { event.preventDefault(); action(); };\n\n        switch (event.key) {\n            case 'ArrowDown': handled(() => moveTo(rows[index + 1])); break;\n            case 'ArrowUp': handled(() => moveTo(rows[index - 1])); break;\n            case 'Home': handled(() => moveTo(rows[0])); break;\n            case 'End': handled(() => moveTo(rows[rows.length - 1])); break;\n            case 'ArrowRight':\n                if (hasChildren) handled(() => { if (!expanded.has(row.key)) { if (enabled) toggle(row.key); } else moveTo(rows[index + 1]); });\n                break;\n            case 'ArrowLeft':\n                if (hasChildren && expanded.has(row.key)) handled(() => { if (enabled) toggle(row.key); });\n                else if (row.parentKey !== undefined) handled(() => moveTo(rows.find(candidate => candidate.key === row.parentKey)));\n                break;\n            case ' ':\n            case 'Enter':\n                handled(() => select(row));\n                break;\n            default:\n                break;\n        }\n    };\n\n    return { tabStopKey, register, activate: setActiveKey, onKeyDown };\n}\n"],"names":["useTreeGridNavigation","rows","expanded","enabled","toggle","select","activeKey","setActiveKey","useState","undefined","elements","useRef","Map","tabStopKey","some","row","key","register","useCallback","element","current","delete","set","moveTo","get","focus","onKeyDown","event","target","currentTarget","index","indexOf","hasChildren","node","children","length","handled","action","preventDefault","has","parentKey","find","candidate","activate"],"mappings":"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"}

package/dist/cjs/editor/PrimeEditor.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var properties = require('../properties.js');
+var QuillLoaderContext = require('./QuillLoaderContext.js');
+var htmlToPlainText = require('./htmlToPlainText.js');
+var renderSafeNodes = require('./renderSafeNodes.js');
+var sanitizeHtml = require('./sanitizeHtml.js');
+var useQuillEditor = require('./useQuillEditor.js');
+
+/**
+ * The `PrimeReact:editor` rich-text control.
+ *
+ * Authored HTML is untrusted data and is never injected as markup. Everywhere it is shown it first goes
+ * through an allowlist (see {@link sanitizeHtml}): into Quill as a Delta, or into the read-only view as React
+ * elements. Where there is no DOM - server rendering, and the first client render so hydration matches - it is
+ * shown as plain text. `element.properties.value` itself is never changed.
+ *
+ * Editing needs Quill, which this package does not import. A host provides it with `QuillLoaderProvider`
+ * (the loader `loadQuill` lives in the `@cratis/scene.primereact/quill` entry point). Without a loader, or if
+ * loading fails, the content stays visible read-only and a status says why; the control never pretends to be
+ * editable.
+ *
+ * `readOnly: true` and `isEnabled: false` both stop editing. Edits are runtime state: `interactions.onChange`
+ * is called when the user edits, but the new HTML is not written back to the document or a binding.
+ */ function PrimeEditor({ element, interactions }) {
+    const loader = react.useContext(QuillLoaderContext.QuillLoaderContext);
+    const host = react.useRef(null);
+    const interactionReference = react.useRef(interactions);
+    interactionReference.current = interactions;
+    const [mounted, setMounted] = react.useState(false);
+    const html = properties.stringProperty(element, 'value', '');
+    const readOnly = properties.booleanProperty(element, 'readOnly', false);
+    const editable = !readOnly && element.isEnabled;
+    const ariaLabel = properties.stringProperty(element, 'ariaLabel', 'Rich text editor');
+    react.useEffect(()=>setMounted(true), []);
+    const editor = useQuillEditor.useQuillEditor({
+        loader,
+        host,
+        html,
+        showHeader: properties.booleanProperty(element, 'showHeader', true),
+        editable,
+        placeholder: properties.stringProperty(element, 'placeholder'),
+        ariaLabel,
+        onUserChange: ()=>interactionReference.current?.onChange?.()
+    });
+    const readOnlyView = react.useMemo(()=>{
+        if (!mounted || typeof DOMParser === 'undefined') return htmlToPlainText.htmlToPlainText(html);
+        return renderSafeNodes.renderSafeNodes(sanitizeHtml.sanitizeHtml(html));
+    }, [
+        mounted,
+        html
+    ]);
+    const status = !editor.ready ? undefined : editable ? `${editor.characters} characters` : readOnly ? 'Read only' : 'Disabled';
+    return /*#__PURE__*/ jsxRuntime.jsxs("section", {
+        "data-scene-id": element.id,
+        "data-scene-component": "editor",
+        onClick: interactions?.onClick,
+        onDoubleClick: interactions?.onDoubleClick,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx("div", {
+                ref: host
+            }),
+            !editor.ready && /*#__PURE__*/ jsxRuntime.jsx("div", {
+                role: "textbox",
+                tabIndex: 0,
+                "aria-multiline": "true",
+                "aria-readonly": "true",
+                "aria-label": ariaLabel,
+                "data-scene-part": "read-only-content",
+                style: typeof readOnlyView === 'string' ? {
+                    whiteSpace: 'pre-wrap'
+                } : undefined,
+                children: readOnlyView
+            }, typeof readOnlyView),
+            editor.failure !== undefined && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                role: "alert",
+                "data-scene-state": "unavailable",
+                children: `Rich-text editing could not be loaded: ${editor.failure}`
+            }),
+            !editor.ready && editor.failure === undefined && loader === undefined && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                role: "status",
+                "data-scene-state": "read-only",
+                children: "Rich-text editing is not available in this application. The content is shown read-only."
+            }),
+            status !== undefined && /*#__PURE__*/ jsxRuntime.jsx("output", {
+                "aria-live": "polite",
+                children: status
+            })
+        ]
+    });
+}
+
+exports.PrimeEditor = PrimeEditor;
+//# sourceMappingURL=PrimeEditor.js.map

package/dist/cjs/editor/PrimeEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeEditor.js","sources":["../../../editor/PrimeEditor.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useContext, useEffect, useMemo, useRef, useState } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\nimport { QuillLoaderContext } from './QuillLoaderContext';\nimport { htmlToPlainText } from './htmlToPlainText';\nimport { renderSafeNodes } from './renderSafeNodes';\nimport { sanitizeHtml } from './sanitizeHtml';\nimport { useQuillEditor } from './useQuillEditor';\n\n/**\n * The `PrimeReact:editor` rich-text control.\n *\n * Authored HTML is untrusted data and is never injected as markup. Everywhere it is shown it first goes\n * through an allowlist (see {@link sanitizeHtml}): into Quill as a Delta, or into the read-only view as React\n * elements. Where there is no DOM - server rendering, and the first client render so hydration matches - it is\n * shown as plain text. `element.properties.value` itself is never changed.\n *\n * Editing needs Quill, which this package does not import. A host provides it with `QuillLoaderProvider`\n * (the loader `loadQuill` lives in the `@cratis/scene.primereact/quill` entry point). Without a loader, or if\n * loading fails, the content stays visible read-only and a status says why; the control never pretends to be\n * editable.\n *\n * `readOnly: true` and `isEnabled: false` both stop editing. Edits are runtime state: `interactions.onChange`\n * is called when the user edits, but the new HTML is not written back to the document or a binding.\n */\nexport function PrimeEditor({ element, interactions }: RegisteredComponentProps) {\n    const loader = useContext(QuillLoaderContext);\n    const host = useRef<HTMLDivElement>(null);\n    const interactionReference = useRef(interactions);\n    interactionReference.current = interactions;\n    const [mounted, setMounted] = useState(false);\n    const html = stringProperty(element, 'value', '');\n    const readOnly = booleanProperty(element, 'readOnly', false);\n    const editable = !readOnly && element.isEnabled;\n    const ariaLabel = stringProperty(element, 'ariaLabel', 'Rich text editor');\n\n    useEffect(() => setMounted(true), []);\n\n    const editor = useQuillEditor({\n        loader,\n        host,\n        html,\n        showHeader: booleanProperty(element, 'showHeader', true),\n        editable,\n        placeholder: stringProperty(element, 'placeholder'),\n        ariaLabel,\n        onUserChange: () => interactionReference.current?.onChange?.(),\n    });\n\n    const readOnlyView = useMemo(() => {\n        if (!mounted || typeof DOMParser === 'undefined') return htmlToPlainText(html);\n        return renderSafeNodes(sanitizeHtml(html));\n    }, [mounted, html]);\n\n    const status = !editor.ready ? undefined : editable ? `${editor.characters} characters` : readOnly ? 'Read only' : 'Disabled';\n\n    return (\n        <section data-scene-id={element.id} data-scene-component='editor' onClick={interactions?.onClick} onDoubleClick={interactions?.onDoubleClick}>\n            <div ref={host} />\n            {!editor.ready && (\n                <div\n                    key={typeof readOnlyView}\n                    role='textbox'\n                    tabIndex={0}\n                    aria-multiline='true'\n                    aria-readonly='true'\n                    aria-label={ariaLabel}\n                    data-scene-part='read-only-content'\n                    style={typeof readOnlyView === 'string' ? { whiteSpace: 'pre-wrap' } : undefined}>\n                    {readOnlyView}\n                </div>\n            )}\n            {editor.failure !== undefined && <p role='alert' data-scene-state='unavailable'>{`Rich-text editing could not be loaded: ${editor.failure}`}</p>}\n            {!editor.ready && editor.failure === undefined && loader === undefined && (\n                <p role='status' data-scene-state='read-only'>Rich-text editing is not available in this application. The content is shown read-only.</p>\n            )}\n            {status !== undefined && <output aria-live='polite'>{status}</output>}\n        </section>\n    );\n}\n"],"names":["PrimeEditor","element","interactions","loader","useContext","QuillLoaderContext","host","useRef","interactionReference","current","mounted","setMounted","useState","html","stringProperty","readOnly","booleanProperty","editable","isEnabled","ariaLabel","useEffect","editor","useQuillEditor","showHeader","placeholder","onUserChange","onChange","readOnlyView","useMemo","DOMParser","htmlToPlainText","renderSafeNodes","sanitizeHtml","status","ready","undefined","characters","_jsxs","section","data-scene-id","id","data-scene-component","onClick","onDoubleClick","_jsx","div","ref","role","tabIndex","aria-multiline","aria-readonly","aria-label","data-scene-part","style","whiteSpace","failure","p","data-scene-state","output","aria-live"],"mappings":"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"}

package/dist/cjs/editor/QuillLoaderContext.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var react = require('react');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** Without a provider there is no loader, and the editor shows its content read-only. */ const QuillLoaderContext = react.createContext(undefined);
+
+exports.QuillLoaderContext = QuillLoaderContext;
+//# sourceMappingURL=QuillLoaderContext.js.map

package/dist/cjs/editor/QuillLoaderContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuillLoaderContext.js","sources":["../../../editor/QuillLoaderContext.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { createContext } from 'react';\nimport { QuillLoader } from './QuillLoader';\n\n/** Without a provider there is no loader, and the editor shows its content read-only. */\nexport const QuillLoaderContext = createContext<QuillLoader | undefined>(undefined);\n"],"names":["QuillLoaderContext","createContext","undefined"],"mappings":";;;;AAAA;AACA;AAKA,0FACO,MAAMA,kBAAAA,GAAqBC,oBAAuCC,SAAAA;;"}

package/dist/cjs/editor/QuillLoaderProvider.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var QuillLoaderContext = require('./QuillLoaderContext.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Makes editable rich text available to the `editor` controls inside it.
+ *
+ * The loader must be a stable reference - define it at module level or memoize it - because the editor
+ * rebuilds when it changes.
+ */ function QuillLoaderProvider({ loader, children }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(QuillLoaderContext.QuillLoaderContext.Provider, {
+        value: loader,
+        children: children
+    });
+}
+
+exports.QuillLoaderProvider = QuillLoaderProvider;
+//# sourceMappingURL=QuillLoaderProvider.js.map

package/dist/cjs/editor/QuillLoaderProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuillLoaderProvider.js","sources":["../../../editor/QuillLoaderProvider.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ReactNode } from 'react';\nimport { QuillLoader } from './QuillLoader';\nimport { QuillLoaderContext } from './QuillLoaderContext';\n\nexport interface QuillLoaderProviderProps {\n    /** Loads Quill. `loadQuill` from `@cratis/scene.primereact/quill` is the ready-made one. */\n    loader: QuillLoader;\n\n    /** The surface whose editors the loader serves. */\n    children: ReactNode;\n}\n\n/**\n * Makes editable rich text available to the `editor` controls inside it.\n *\n * The loader must be a stable reference - define it at module level or memoize it - because the editor\n * rebuilds when it changes.\n */\nexport function QuillLoaderProvider({ loader, children }: QuillLoaderProviderProps) {\n    return <QuillLoaderContext.Provider value={loader}>{children}</QuillLoaderContext.Provider>;\n}\n"],"names":["QuillLoaderProvider","loader","children","_jsx","QuillLoaderContext","Provider","value"],"mappings":";;;;;AAAA;AACA;AAcA;;;;;AAKC,IACM,SAASA,mBAAAA,CAAoB,EAAEC,MAAM,EAAEC,QAAQ,EAA4B,EAAA;IAC9E,qBAAOC,cAAA,CAACC,sCAAmBC,QAAQ,EAAA;QAACC,KAAAA,EAAOL,MAAAA;AAASC,QAAAA,QAAAA,EAAAA;;AACxD;;"}

package/dist/cjs/editor/applyHtml.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var sanitizeHtml = require('./sanitizeHtml.js');
+var serializeSafeNodes = require('./serializeSafeNodes.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Puts authored HTML into a Quill editor, silently.
+ *
+ * The HTML first goes through the allowlist, and what is left is converted by Quill's clipboard into a Delta
+ * that `setContents` applies. The authored string is never assigned to `innerHTML`, so nothing in it can run;
+ * and because the change is `'silent'` it raises no `text-change`, so loading a document is not reported as
+ * the user editing it.
+ *
+ * @param quill The editor.
+ * @param html The authored HTML.
+ */ function applyHtml(quill, html) {
+    quill.setContents(quill.clipboard.convert({
+        html: serializeSafeNodes.serializeSafeNodes(sanitizeHtml.sanitizeHtml(html))
+    }), 'silent');
+}
+
+exports.applyHtml = applyHtml;
+//# sourceMappingURL=applyHtml.js.map

package/dist/cjs/editor/applyHtml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyHtml.js","sources":["../../../editor/applyHtml.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { QuillInstance } from './QuillInstance';\nimport { sanitizeHtml } from './sanitizeHtml';\nimport { serializeSafeNodes } from './serializeSafeNodes';\n\n/**\n * Puts authored HTML into a Quill editor, silently.\n *\n * The HTML first goes through the allowlist, and what is left is converted by Quill's clipboard into a Delta\n * that `setContents` applies. The authored string is never assigned to `innerHTML`, so nothing in it can run;\n * and because the change is `'silent'` it raises no `text-change`, so loading a document is not reported as\n * the user editing it.\n *\n * @param quill The editor.\n * @param html The authored HTML.\n */\nexport function applyHtml(quill: QuillInstance, html: string): void {\n    quill.setContents(quill.clipboard.convert({ html: serializeSafeNodes(sanitizeHtml(html)) }), 'silent');\n}\n"],"names":["applyHtml","quill","html","setContents","clipboard","convert","serializeSafeNodes","sanitizeHtml"],"mappings":";;;;;AAAA;AACA;AAMA;;;;;;;;;;AAUC,IACM,SAASA,SAAAA,CAAUC,KAAoB,EAAEC,IAAY,EAAA;AACxDD,IAAAA,KAAAA,CAAME,WAAW,CAACF,KAAAA,CAAMG,SAAS,CAACC,OAAO,CAAC;AAAEH,QAAAA,IAAAA,EAAMI,sCAAmBC,yBAAAA,CAAaL,IAAAA,CAAAA;KAAO,CAAA,EAAI,QAAA,CAAA;AACjG;;"}

package/dist/cjs/editor/characterCount.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The number of characters of text in the editor, not counting the newline Quill always ends with. */ function characterCount(quill) {
+    return Math.max(quill.getText().length - 1, 0);
+}
+
+exports.characterCount = characterCount;
+//# sourceMappingURL=characterCount.js.map

package/dist/cjs/editor/characterCount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"characterCount.js","sources":["../../../editor/characterCount.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { QuillInstance } from './QuillInstance';\n\n/** The number of characters of text in the editor, not counting the newline Quill always ends with. */\nexport function characterCount(quill: QuillInstance): number {\n    return Math.max(quill.getText().length - 1, 0);\n}\n"],"names":["characterCount","quill","Math","max","getText","length"],"mappings":";;AAAA;AACA;AAIA,wGACO,SAASA,cAAAA,CAAeC,KAAoB,EAAA;IAC/C,OAAOC,IAAAA,CAAKC,GAAG,CAACF,KAAAA,CAAMG,OAAO,EAAA,CAAGC,MAAM,GAAG,CAAA,EAAG,CAAA,CAAA;AAChD;;"}

package/dist/cjs/editor/htmlToPlainText.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** Elements dropped together with their content, as `sanitizeHtml` does. */ const discardedWithContent = new Set([
+    'script',
+    'style',
+    'template',
+    'noscript',
+    'iframe',
+    'object',
+    'embed',
+    'svg',
+    'math',
+    'textarea',
+    'title',
+    'head'
+]);
+/** Elements after which a line break reads naturally. */ const breaking = new Set([
+    'p',
+    'div',
+    'br',
+    'hr',
+    'li',
+    'tr',
+    'blockquote',
+    'pre',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6'
+]);
+const namedEntities = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' '
+};
+/**
+ * Reads authored HTML as plain text, without a DOM.
+ *
+ * This is what server rendering shows, where there is no `DOMParser` to build safe markup with. The result
+ * is only ever rendered as text, which React escapes, so it cannot carry markup however the input is built.
+ * It scans once, left to right: tags are dropped, script, style and similar elements go with their content,
+ * and block elements become line breaks.
+ *
+ * @param html The authored HTML.
+ * @returns The text, with line breaks between blocks.
+ */ function htmlToPlainText(html) {
+    const lower = html.toLowerCase();
+    let text = '';
+    let position = 0;
+    while(position < html.length){
+        const open = html.indexOf('<', position);
+        if (open === -1) {
+            text += html.slice(position);
+            break;
+        }
+        text += html.slice(position, open);
+        if (!/[a-z/!?]/i.test(html[open + 1] ?? '')) {
+            text += '<';
+            position = open + 1;
+            continue;
+        }
+        if (lower.startsWith('<!--', open)) {
+            const close = html.indexOf('-->', open + 4);
+            position = close === -1 ? html.length : close + 3;
+            continue;
+        }
+        const close = html.indexOf('>', open);
+        if (close === -1) {
+            text += html.slice(open);
+            break;
+        }
+        const name = /^<\/?([a-z][a-z0-9]*)/.exec(lower.slice(open, close + 1))?.[1];
+        position = close + 1;
+        if (name === undefined) continue;
+        if (lower[open + 1] !== '/' && discardedWithContent.has(name)) {
+            const end = lower.indexOf(`</${name}`, position);
+            const endClose = end === -1 ? -1 : html.indexOf('>', end);
+            position = endClose === -1 ? html.length : endClose + 1;
+        } else if (breaking.has(name) && (lower[open + 1] === '/' || name === 'br' || name === 'hr')) {
+            text += '\n';
+        }
+    }
+    return decodeEntities(text).replace(/\n{3,}/g, '\n\n').trim();
+}
+function decodeEntities(text) {
+    return text.replace(/&(#x[0-9a-f]{1,6}|#[0-9]{1,7}|[a-z]+);/gi, (match, entity)=>{
+        if (entity[0] !== '#') return namedEntities[entity.toLowerCase()] ?? match;
+        const code = entity[1].toLowerCase() === 'x' ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+        return code > 0 && code <= 0x10ffff && !(code >= 0xd800 && code <= 0xdfff) ? String.fromCodePoint(code) : match;
+    });
+}
+
+exports.htmlToPlainText = htmlToPlainText;
+//# sourceMappingURL=htmlToPlainText.js.map

package/dist/cjs/editor/htmlToPlainText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlToPlainText.js","sources":["../../../editor/htmlToPlainText.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** Elements dropped together with their content, as `sanitizeHtml` does. */\nconst discardedWithContent = new Set(['script', 'style', 'template', 'noscript', 'iframe', 'object', 'embed', 'svg', 'math', 'textarea', 'title', 'head']);\n\n/** Elements after which a line break reads naturally. */\nconst breaking = new Set(['p', 'div', 'br', 'hr', 'li', 'tr', 'blockquote', 'pre', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']);\n\nconst namedEntities: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '\"', apos: \"'\", nbsp: ' ' };\n\n/**\n * Reads authored HTML as plain text, without a DOM.\n *\n * This is what server rendering shows, where there is no `DOMParser` to build safe markup with. The result\n * is only ever rendered as text, which React escapes, so it cannot carry markup however the input is built.\n * It scans once, left to right: tags are dropped, script, style and similar elements go with their content,\n * and block elements become line breaks.\n *\n * @param html The authored HTML.\n * @returns The text, with line breaks between blocks.\n */\nexport function htmlToPlainText(html: string): string {\n    const lower = html.toLowerCase();\n    let text = '';\n    let position = 0;\n    while (position < html.length) {\n        const open = html.indexOf('<', position);\n        if (open === -1) {\n            text += html.slice(position);\n            break;\n        }\n\n        text += html.slice(position, open);\n        if (!/[a-z/!?]/i.test(html[open + 1] ?? '')) {\n            text += '<';\n            position = open + 1;\n            continue;\n        }\n\n        if (lower.startsWith('<!--', open)) {\n            const close = html.indexOf('-->', open + 4);\n            position = close === -1 ? html.length : close + 3;\n            continue;\n        }\n\n        const close = html.indexOf('>', open);\n        if (close === -1) {\n            text += html.slice(open);\n            break;\n        }\n\n        const name = /^<\\/?([a-z][a-z0-9]*)/.exec(lower.slice(open, close + 1))?.[1];\n        position = close + 1;\n        if (name === undefined) continue;\n        if (lower[open + 1] !== '/' && discardedWithContent.has(name)) {\n            const end = lower.indexOf(`</${name}`, position);\n            const endClose = end === -1 ? -1 : html.indexOf('>', end);\n            position = endClose === -1 ? html.length : endClose + 1;\n        } else if (breaking.has(name) && (lower[open + 1] === '/' || name === 'br' || name === 'hr')) {\n            text += '\\n';\n        }\n    }\n\n    return decodeEntities(text).replace(/\\n{3,}/g, '\\n\\n').trim();\n}\n\nfunction decodeEntities(text: string): string {\n    return text.replace(/&(#x[0-9a-f]{1,6}|#[0-9]{1,7}|[a-z]+);/gi, (match, entity: string) => {\n        if (entity[0] !== '#') return namedEntities[entity.toLowerCase()] ?? match;\n        const code = entity[1].toLowerCase() === 'x' ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);\n        return code > 0 && code <= 0x10ffff && !(code >= 0xd800 && code <= 0xdfff) ? String.fromCodePoint(code) : match;\n    });\n}\n"],"names":["discardedWithContent","Set","breaking","namedEntities","amp","lt","gt","quot","apos","nbsp","htmlToPlainText","html","lower","toLowerCase","text","position","length","open","indexOf","slice","test","startsWith","close","name","exec","undefined","has","end","endClose","decodeEntities","replace","trim","match","entity","code","parseInt","String","fromCodePoint"],"mappings":"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"}

package/dist/cjs/editor/renderSafeNodes.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var react = require('react');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+const voidTags = new Set([
+    'br',
+    'hr',
+    'img'
+]);
+/**
+ * Renders safe nodes as React elements.
+ *
+ * Nothing is ever injected as markup: each node becomes an element created from the allowlisted tag name with
+ * the validated attributes, and text goes through React's escaping. Links are made `noopener noreferrer` and
+ * open in the same context.
+ *
+ * @param nodes The nodes `sanitizeHtml` returned.
+ */ function renderSafeNodes(nodes) {
+    return nodes.map((node, index)=>{
+        if (typeof node === 'string') return node;
+        const { class: className, ...attributes } = node.attributes;
+        const properties = {
+            key: String(index),
+            className,
+            ...attributes
+        };
+        if (node.tag === 'a') properties.rel = 'noopener noreferrer';
+        return /*#__PURE__*/ react.createElement(node.tag, properties, ...voidTags.has(node.tag) ? [] : renderSafeNodes(node.children));
+    });
+}
+
+exports.renderSafeNodes = renderSafeNodes;
+//# sourceMappingURL=renderSafeNodes.js.map