@nascentdigital/funnel-core 4.4.4

package/dist/ui/richtext/LexicalUtils.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexicalUtils = void 0;
+const selection_1 = require("@lexical/selection");
+const lexical_1 = require("lexical");
+const utils_1 = require("../../utils");
+const geometry_1 = require("../geometry");
+const StyledTextNode_1 = require("./StyledTextNode");
+// extensions
+var LexicalUtils;
+(function (LexicalUtils) {
+    // guards
+    function isSerializedTextNode(node) {
+        return utils_1.ObjectUtils.hasKeys(node, 'text', 'detail', 'format')
+            && typeof node.text === 'string'
+            && typeof node.detail === 'number'
+            && typeof node.format === 'number';
+    }
+    LexicalUtils.isSerializedTextNode = isSerializedTextNode;
+    function isSerializedParagraphNode(node) {
+        return node.type === 'paragraph'
+            && utils_1.ObjectUtils.hasKeys(node, 'textFormat', 'textStyle')
+            && typeof node.textFormat === 'number'
+            && typeof node.textStyle === 'string';
+    }
+    LexicalUtils.isSerializedParagraphNode = isSerializedParagraphNode;
+    function isSerializedHeadingNode(node) {
+        return node.type === 'heading';
+    }
+    LexicalUtils.isSerializedHeadingNode = isSerializedHeadingNode;
+    function isSerializedQuoteNode(node) {
+        return node.type === 'quote';
+    }
+    LexicalUtils.isSerializedQuoteNode = isSerializedQuoteNode;
+    function isSerializedListNode(node) {
+        return node.type === 'list'
+            && utils_1.ObjectUtils.hasKeys(node, 'listType', 'start', 'tag')
+            && typeof node.listType === 'string'
+            && typeof node.start === 'number'
+            && typeof node.tag === 'string';
+    }
+    LexicalUtils.isSerializedListNode = isSerializedListNode;
+    function isSerializedHrNode(node) {
+        return node.type === 'horizontalrule';
+    }
+    LexicalUtils.isSerializedHrNode = isSerializedHrNode;
+    function isSerializedListItemNode(node) {
+        return node.type === 'listitem'
+            && utils_1.ObjectUtils.hasKeys(node, 'value')
+            && typeof node.value === 'number';
+    }
+    LexicalUtils.isSerializedListItemNode = isSerializedListItemNode;
+    function isSerializedLinkNode(node) {
+        return node.type === 'link'
+            && utils_1.ObjectUtils.hasKeys(node, 'url')
+            && typeof node.url === 'string';
+    }
+    LexicalUtils.isSerializedLinkNode = isSerializedLinkNode;
+    function isSerializedElementNode(node) {
+        return utils_1.ObjectUtils.hasKeys(node, 'children', 'indent')
+            && Array.isArray(node.children)
+            && typeof node.indent === 'number';
+    }
+    LexicalUtils.isSerializedElementNode = isSerializedElementNode;
+    // methods
+    function rootToString(root) {
+        // skip if there's no root
+        if (!root) {
+            return '';
+        }
+        // helper
+        const nodeToString = (node) => {
+            if (LexicalUtils.isSerializedElementNode(node)) {
+                // render contents
+                return LexicalUtils.isSerializedHrNode(node)
+                    ? '-'
+                    : node.children.map(nodeToString).join('');
+            }
+            // or render text
+            else if (node.type === 'text' && LexicalUtils.isSerializedTextNode(node)) {
+                return node.text;
+            }
+            // or render 'styled' node
+            else if (StyledTextNode_1.StyledTextNode.Data.filter(node)) {
+                return node.text;
+            }
+            // or render line break
+            else if (node.type === 'horizontalrule') {
+                return '-';
+            }
+            // or skip unknown node
+            else {
+                return '';
+            }
+        };
+        // process nodes
+        return root.children.map(nodeToString).join('');
+    }
+    LexicalUtils.rootToString = rootToString;
+    function replaceTextNodes({ selection: selectionRaw, onReplaceNode }) {
+        // skip if it's not a range
+        const selection = selectionRaw === undefined
+            ? (0, lexical_1.$getSelection)()
+            : selectionRaw;
+        if (!(0, lexical_1.$isRangeSelection)(selection)) {
+            console.debug('[LexicalUtils/replaceTextNodes] no range selected');
+            return false;
+        }
+        // get selected nodes
+        const selectedTextNodes = [];
+        (0, selection_1.$forEachSelectedTextNode)(textNode => selectedTextNodes.push(textNode));
+        const selectedTextNodesLength = selectedTextNodes.length;
+        // skip if there is no selection
+        const { anchor, focus } = selection;
+        const isBackward = selection.isBackward();
+        const startPoint = isBackward ? focus : anchor;
+        const endPoint = isBackward ? anchor : focus;
+        if (selectedTextNodesLength === 0) {
+            // handle case where selection is on a text node
+            const node = startPoint.getNode();
+            if (startPoint.is(endPoint)
+                && startPoint.type === 'text'
+                && startPoint.offset === endPoint.offset
+                && node instanceof lexical_1.TextNode) {
+                // determine start offset
+                const text = node.getTextContent();
+                let startOffset = startPoint.offset;
+                while (startOffset > 0 && text[startOffset - 1] !== ' ') {
+                    --startOffset;
+                }
+                // determine end offset
+                const textLength = text.length;
+                let endOffset = startPoint.offset;
+                while (endOffset < textLength && text[endOffset] !== ' ') {
+                    ++endOffset;
+                }
+                // split text
+                const splitNodes = node.splitText(startOffset, endOffset);
+                const replacement = onReplaceNode(startOffset === 0 ? splitNodes[0] : splitNodes[1]);
+                // adjust selection
+                if (startPoint.type === 'text') {
+                    startPoint.set(replacement.__key, 0, 'text');
+                }
+                if (endPoint.type === 'text') {
+                    endPoint.set(replacement.__key, endOffset - startOffset, 'text');
+                }
+                return true;
+            }
+            // otherwise, assume there's nothing to select
+            else {
+                console.debug('[LexicalUtils/replaceTextNodes] no text selected');
+                return false;
+            }
+        }
+        // get selected text nodes (or stop
+        console.debug('[LexicalUtils/replaceTextNodes] toggling style on text nodes', selectedTextNodes);
+        // assume starting at beginning of selection
+        let firstIndex = 0;
+        let firstNode = selectedTextNodes[0];
+        let startOffset = startPoint.type === 'element' ? 0 : startPoint.offset;
+        // move selection if it's at the end of a text node
+        if (startPoint.type === 'text' && startOffset === firstNode.getTextContentSize()) {
+            console.debug('[LexicalUtils/replaceTextNodes] adjusting selection from the end of previous node');
+            firstIndex = 1;
+            firstNode = selectedTextNodes[1];
+            startOffset = 0;
+        }
+        console.debug('[LexicalUtils/replaceTextNodes] resolved selection start', {
+            isBackward, startPoint, endPoint, firstNode
+        });
+        // stop if there's no first node
+        if (firstNode == null) {
+            console.debug('[LexicalUtils/replaceTextNodes] no first node to process');
+            return false;
+        }
+        // find end of selection
+        const lastIndex = selectedTextNodesLength - 1;
+        let lastNode = selectedTextNodes[lastIndex];
+        const endOffset = endPoint.type === 'text'
+            ? endPoint.offset
+            : lastNode.getTextContentSize();
+        console.debug('[LexicalUtils/replaceTextNodes] resolved selection end', {
+            lastIndex, endOffset, lastNode
+        });
+        // handle single node selection
+        if (firstNode.is(lastNode)) {
+            console.debug('[LexicalUtils/replaceTextNodes] handling single node selection');
+            // skip if there's no selection
+            if (startOffset === endOffset) {
+                console.debug('[LexicalUtils/replaceTextNodes] no selection to process');
+                return false;
+            }
+            // format the entire node if selected (or if it's a token
+            if ((0, lexical_1.$isTokenOrSegmented)(firstNode)
+                || (startOffset === 0 && endOffset === firstNode.getTextContentSize())) {
+                console.debug('[LexicalUtils/replaceTextNodes] formatting entire node');
+                onReplaceNode(firstNode);
+            }
+            // or split the node if it's partially selected and style the selected fragment
+            else {
+                console.debug('[LexicalUtils/replaceTextNodes] partial node selection');
+                // determine the replacement
+                const splitNodes = firstNode.splitText(startOffset, endOffset);
+                const replacement = onReplaceNode(startOffset === 0 ? splitNodes[0] : splitNodes[1]);
+                // adjust selection
+                if (startPoint.type === 'text') {
+                    startPoint.set(replacement.__key, 0, 'text');
+                }
+                if (endPoint.type === 'text') {
+                    endPoint.set(replacement.__key, endOffset - startOffset, 'text');
+                }
+            }
+        }
+        // TODO: handle multiple nodes being replaced
+        else {
+            console.debug('[LexicalUtils/replaceTextNodes] handling multi node selection');
+            // split the first node if it  isn't fully selected
+            if (startOffset !== 0 && !(0, lexical_1.$isTokenOrSegmented)(firstNode)) {
+                [, firstNode] = firstNode.splitText(startOffset);
+                startOffset = 0;
+            }
+            // TODO: should we merge nodes?
+            // style the first mode
+            onReplaceNode(firstNode);
+            // skip last node of the end offset is 0
+            if (endOffset > 0) {
+                // split last node if it isn't fully selected
+                if (endOffset !== lastNode.getTextContentSize() && !(0, lexical_1.$isTokenOrSegmented)(lastNode)) {
+                    [lastNode] = lastNode.splitText(endOffset);
+                }
+                // toggle style on last node
+                onReplaceNode(lastNode);
+            }
+            // process all nodes in between
+            for (let i = firstIndex + 1; i < lastIndex; i++) {
+                onReplaceNode(selectedTextNodes[i]);
+            }
+            // update start/end selection (if able to)
+            if (startPoint.type === 'text') {
+                startPoint.set(firstNode.__key, startOffset, 'text');
+            }
+            if (endPoint.type === 'text') {
+                endPoint.set(lastNode.__key, endOffset, 'text');
+            }
+        }
+        // indicate success
+        return true;
+    }
+    LexicalUtils.replaceTextNodes = replaceTextNodes;
+    function findContainer(node, types) {
+        // search for match within ancestors
+        let parent = node;
+        while (parent) {
+            // stop if a match is found
+            for (const klass of types) {
+                if (parent instanceof klass) {
+                    return parent;
+                }
+            }
+            // keep walking upwards
+            parent = parent.getParent();
+        }
+        // return undefined if there's no match
+        return undefined;
+    }
+    LexicalUtils.findContainer = findContainer;
+    function getSelectionRect({ editor, selection: selectionRaw, coerce = false, allowEmpty = false }) {
+        var _a, _b;
+        // skip if there's no selection
+        if (!selectionRaw) {
+            return;
+        }
+        // use given range
+        let selection;
+        if ((0, lexical_1.$isRangeSelection)(selectionRaw)) {
+            selection = selectionRaw;
+        }
+        // or coerce if allowed
+        else if (coerce) {
+            const [focusNode] = selectionRaw.getNodes();
+            const parentNode = findContainer(focusNode, typeof coerce === 'boolean' ? [lexical_1.ElementNode] : coerce);
+            const textNodes = (_a = parentNode === null || parentNode === void 0 ? void 0 : parentNode.getAllTextNodes()) !== null && _a !== void 0 ? _a : [];
+            if (textNodes.length > 0) {
+                const [anchorNode] = textNodes;
+                const focusNode = (_b = utils_1.ArrayUtils.last(textNodes)) !== null && _b !== void 0 ? _b : anchorNode;
+                selection = (0, lexical_1.$createRangeSelection)();
+                selection.setTextNodeRange(anchorNode, 0, focusNode, focusNode.getTextContentSize());
+            }
+        }
+        // skip if there's no node OR no selection
+        if (!selection) {
+            return;
+        }
+        // or skip if we require content and it's empty
+        else if (!allowEmpty && selection.getTextContent().length === 0) {
+            return;
+        }
+        // skip if there's no dom range
+        const domRange = (0, selection_1.createDOMRange)(editor, selection.anchor.getNode(), selection.anchor.offset, selection.focus.getNode(), selection.focus.offset);
+        if (!domRange) {
+            return undefined;
+        }
+        // or skip if there's no selection
+        const [anchorRect] = (0, selection_1.createRectsFromDOMRange)(editor, domRange);
+        if (!anchorRect) {
+            return undefined;
+        }
+        // or show popup
+        else {
+            return geometry_1.Rect.fromRect(anchorRect);
+        }
+    }
+    LexicalUtils.getSelectionRect = getSelectionRect;
+})(LexicalUtils || (exports.LexicalUtils = LexicalUtils = {}));

package/dist/ui/richtext/StyledTextNode.d.ts

@@ -0,0 +1,33 @@
+import { type EditorConfig, LexicalCommand, type LexicalNode, SerializedLexicalNode, SerializedTextNode, TextNode } from 'lexical';
+export declare class StyledTextNode extends TextNode {
+    $config(): import("lexical").StaticNodeConfigRecord<"styled", {
+        extends: typeof TextNode;
+        stateConfigs: {
+            stateConfig: import("lexical").StateConfig<"styled", StyledTextNode.Style>;
+            flat: true;
+        }[];
+    }>;
+    getStyleFormat(): StyledTextNode.Style;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: this, element: HTMLElement, config: EditorConfig): boolean;
+}
+export declare namespace StyledTextNode {
+    type Data = Omit<SerializedTextNode, 'type'> & {
+        type: typeof Type;
+        styled?: Style;
+    };
+    namespace Data {
+        function filter(node: SerializedLexicalNode): node is Data;
+    }
+    type Style = 'priority' | 'accent' | 'subtle';
+    namespace Style {
+        const values: ReadonlyArray<Style>;
+        function filter(value: string): value is Style;
+        function coerce(value: any): Style;
+        function updateClasses(element: HTMLElement, style: Style): void;
+    }
+    const FORMAT_STYLED_TEXT_COMMAND: LexicalCommand<Style>;
+    const Type: "styled";
+    function $createStyledTextNode(text: string, style: Style): StyledTextNode;
+    function $isStyledTextNode(node: LexicalNode | null | undefined): node is StyledTextNode;
+}

package/dist/ui/richtext/StyledTextNode.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyledTextNode = void 0;
+const lexical_1 = require("lexical");
+const utils_1 = require("../../utils");
+// node
+class StyledTextNode extends lexical_1.TextNode {
+    $config() {
+        return this.config(StyledTextNode.Type, {
+            extends: lexical_1.TextNode,
+            stateConfigs: [{ stateConfig: styledState, flat: true }]
+        });
+    }
+    getStyleFormat() {
+        return (0, lexical_1.$getState)(this, styledState);
+    }
+    createDOM(config) {
+        // update element based on current styles
+        const element = super.createDOM(config);
+        const style = (0, lexical_1.$getState)(this, styledState);
+        StyledTextNode.Style.updateClasses(element, style);
+        // return element
+        return element;
+    }
+    updateDOM(prevNode, element, config) {
+        var _a;
+        // skip if already handled
+        if (super.updateDOM(prevNode, element, config)) {
+            return true;
+        }
+        // update style if it's not changed
+        const [style] = (_a = (0, lexical_1.$getStateChange)(this, prevNode, styledState)) !== null && _a !== void 0 ? _a : [];
+        if (style) {
+            StyledTextNode.Style.updateClasses(element, style);
+        }
+        // mark as handled
+        return false;
+    }
+}
+exports.StyledTextNode = StyledTextNode;
+// extensions
+(function (StyledTextNode) {
+    let Data;
+    (function (Data) {
+        // methods
+        function filter(node) {
+            return node.type === 'styled';
+        }
+        Data.filter = filter;
+    })(Data = StyledTextNode.Data || (StyledTextNode.Data = {}));
+    let Style;
+    (function (Style) {
+        // values
+        Style.values = [
+            'priority', 'accent', 'subtle'
+        ];
+        // methods
+        function filter(value) {
+            return Style.values.includes(value);
+        }
+        Style.filter = filter;
+        function coerce(value) {
+            return utils_1.Value.typeOf(value) === 'string' && filter(value)
+                ? value
+                : 'priority';
+        }
+        Style.coerce = coerce;
+        function updateClasses(element, style) {
+            // remove unused classes
+            const { classList } = element;
+            switch (style) {
+                case 'priority':
+                    classList.add('priority', 'text-primary', 'font-bold');
+                    break;
+                case 'accent':
+                    classList.add('accent', 'bg-primary-tint/faded');
+                    break;
+                case 'subtle':
+                    classList.add('subtle', 'text-ix-disabled-content', 'font-bold');
+                    break;
+            }
+        }
+        Style.updateClasses = updateClasses;
+    })(Style = StyledTextNode.Style || (StyledTextNode.Style = {}));
+    // values
+    StyledTextNode.FORMAT_STYLED_TEXT_COMMAND = (0, lexical_1.createCommand)('styledText.insert');
+    StyledTextNode.Type = 'styled';
+    // methods
+    function $createStyledTextNode(text, style) {
+        return (0, lexical_1.$setState)((0, lexical_1.$create)(StyledTextNode).setTextContent(text), styledState, style);
+    }
+    StyledTextNode.$createStyledTextNode = $createStyledTextNode;
+    function $isStyledTextNode(node) {
+        return node instanceof StyledTextNode;
+    }
+    StyledTextNode.$isStyledTextNode = $isStyledTextNode;
+})(StyledTextNode || (exports.StyledTextNode = StyledTextNode = {}));
+// helpers
+const styledState = (0, lexical_1.createState)('styled', {
+    parse: value => StyledTextNode.Style.coerce(value)
+});

package/dist/ui/richtext/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LexicalUtils';
+export * from './StyledTextNode';

package/dist/ui/richtext/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LexicalUtils"), exports);
+__exportStar(require("./StyledTextNode"), exports);

package/dist/utils/ArrayUtils.d.ts

@@ -0,0 +1,17 @@
+import { JsonValue } from 'type-fest';
+import { Transform } from '../types';
+export declare namespace ArrayUtils {
+    function coerce<T>(maybeArray: T[] | T | undefined | null): T[];
+    function first<T>(array: ReadonlyArray<T>): T | undefined;
+    function last<T>(array: ReadonlyArray<T>): T | undefined;
+    /**
+     * Creates a sequential array of items from [start, end] inclusive, incrementing by 1.
+     *
+     * @param end - the end of the series (inclusive)
+     * @param start - the first element in the series (inclusive - defaults to 0)
+     */
+    function series(end: number, start?: number): number[];
+    function fill<T extends JsonValue>(count: number, generatorOrValue: Transform<number, T> | T): T[];
+    function circularIndex(arrayOrLength: ReadonlyArray<unknown> | number, index: number): number;
+    function circularGet<T>(array: ReadonlyArray<T>, index: number): T;
+}

package/dist/utils/ArrayUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUtils = void 0;
+// namespace
+var ArrayUtils;
+(function (ArrayUtils) {
+    function coerce(maybeArray) {
+        return maybeArray
+            ? Array.isArray(maybeArray)
+                ? maybeArray
+                : [maybeArray]
+            : [];
+    }
+    ArrayUtils.coerce = coerce;
+    function first(array) {
+        return array.length > 0
+            ? array[0]
+            : undefined;
+    }
+    ArrayUtils.first = first;
+    function last(array) {
+        return array.length > 0
+            ? array[array.length - 1]
+            : undefined;
+    }
+    ArrayUtils.last = last;
+    /**
+     * Creates a sequential array of items from [start, end] inclusive, incrementing by 1.
+     *
+     * @param end - the end of the series (inclusive)
+     * @param start - the first element in the series (inclusive - defaults to 0)
+     */
+    function series(end, start = 0) {
+        // determine size
+        const size = end - start + 1;
+        // create array + populate
+        const series = Array(size);
+        for (let i = 0; i < size; ++i) {
+            series[i] = i + start;
+        }
+        // return series
+        return series;
+    }
+    ArrayUtils.series = series;
+    function fill(count, generatorOrValue) {
+        // create array
+        if (typeof generatorOrValue === 'function') {
+            return Array(count).fill(undefined)
+                .map((_, index) => generatorOrValue(index));
+        }
+        // or just fill it with the value
+        else {
+            return Array(count).fill(generatorOrValue);
+        }
+    }
+    ArrayUtils.fill = fill;
+    function circularIndex(arrayOrLength, index) {
+        const length = typeof arrayOrLength === 'number' ? arrayOrLength : arrayOrLength.length;
+        return (index % length + length) % length;
+    }
+    ArrayUtils.circularIndex = circularIndex;
+    function circularGet(array, index) {
+        return array[circularIndex(array, index)];
+    }
+    ArrayUtils.circularGet = circularGet;
+})(ArrayUtils || (exports.ArrayUtils = ArrayUtils = {}));

package/dist/utils/ByteSize.d.ts

@@ -0,0 +1,19 @@
+export declare class ByteSize {
+    private _bytes;
+    constructor(bytes: number);
+    get value(): number;
+    set value(bytes: number);
+    components({ precision }?: ByteSize.ComponentsOptions): ByteSize.Components;
+    static fromKb(kiloBytes: number): ByteSize;
+    static formMb(megabytes: number): ByteSize;
+}
+export declare namespace ByteSize {
+    type Components = {
+        size: string;
+        units: string;
+        unitsLong: string;
+    };
+    type ComponentsOptions = {
+        precision?: number;
+    };
+}

package/dist/utils/ByteSize.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteSize = void 0;
+const byte_size_1 = __importDefault(require("byte-size"));
+// namespace
+class ByteSize {
+    constructor(bytes) {
+        // initialize instance variables
+        this._bytes = bytes;
+    }
+    get value() {
+        return this._bytes;
+    }
+    set value(bytes) {
+        this._bytes = bytes;
+    }
+    components({ precision = 1 } = {}) {
+        // parse bytes
+        const { value: size, unit: units, long: unitsLong } = (0, byte_size_1.default)(this._bytes, { precision });
+        // return components
+        return { size, units, unitsLong };
+    }
+    static fromKb(kiloBytes) {
+        return new ByteSize(kiloBytes * 1000);
+    }
+    static formMb(megabytes) {
+        return new ByteSize(megabytes * 1000000);
+    }
+}
+exports.ByteSize = ByteSize;

package/dist/utils/DateUtils.d.ts

@@ -0,0 +1,15 @@
+export declare namespace DateUtils {
+    type DateLike = number | Date;
+    type Resolution = 'second' | 'minute';
+    const minute = 60;
+    const hour: number;
+    const day: number;
+    function ageInSeconds(from: DateLike, to?: DateLike): number;
+    function ageInWeeks(from: DateLike, to?: DateLike): number;
+    type FormatOptions = {
+        variant?: FormatVariant;
+    };
+    type FormatVariant = 'datetime' | 'date' | 'full-numeric';
+    function format(time: DateLike, { variant }?: FormatOptions): string;
+    function formatAge(from: DateLike, resolution?: Resolution): string;
+}