dustyui 1.0.2 → 2.0.0

package/dist/ObjectInspector/describe/getPreview.js

@@ -0,0 +1,189 @@
+import { getValueKind } from "./getValueKind.js";
+import { getConstructorName, getDataProperty, getDateTime, getFailureReason, getMapSize, getRegExpText, getSetSize, getSymbolText, getTypedArrayLength, isClass, } from "./safeRead.js";
+const MAX_TEXT_LENGTH = 80;
+const MAX_NESTED_TEXT_LENGTH = 20;
+const MAX_MEMBERS = 5;
+const ELLIPSIS = "…";
+const GETTER = "(...)";
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+const LINE_BREAKING = /[\p{Cc}\u2028\u2029]/gu;
+function toSingleLine(text) {
+    return text.replace(LINE_BREAKING, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function truncate(text, limit) {
+    const characters = Array.from(text);
+    return characters.length > limit
+        ? `${characters.slice(0, limit).join("")}${ELLIPSIS}`
+        : text;
+}
+function quote(text, limit) {
+    return JSON.stringify(truncate(text, limit));
+}
+function withSize(name, size) {
+    return `${name}(${size})`;
+}
+function getArrayLength(value) {
+    try {
+        return getTypedArrayLength(value);
+    }
+    catch {
+        const length = getDataProperty(value, "length");
+        return typeof length === "number" ? length : 0;
+    }
+}
+function getUninspectablePreview(reason) {
+    return `Uninspectable: ${truncate(reason, MAX_TEXT_LENGTH)}`;
+}
+function getFunctionPreview(value) {
+    const name = getDataProperty(value, "name");
+    const label = typeof name === "string" ? truncate(name, MAX_NESTED_TEXT_LENGTH) : "";
+    return isClass(value) ? `class ${label}`.trimEnd() : `ƒ ${label}()`;
+}
+function getDatePreview(value) {
+    const time = getDateTime(value);
+    return Number.isNaN(time) ? "Invalid Date" : new Date(time).toISOString();
+}
+function getErrorPreview(value) {
+    const name = getConstructorName(value) ?? "Error";
+    const message = getDataProperty(value, "message");
+    return typeof message === "string" && message !== ""
+        ? `${name}: ${truncate(message, MAX_TEXT_LENGTH)}`
+        : name;
+}
+function getPrimitivePreview(value, kind, textLimit) {
+    switch (kind) {
+        case "string":
+            return quote(value, textLimit);
+        case "number":
+            return Object.is(value, -0) ? "-0" : String(value);
+        case "bigint":
+            return `${String(value)}n`;
+        case "boolean":
+        case "null":
+        case "undefined":
+            return String(value);
+        case "symbol":
+            return truncate(getSymbolText(value), textLimit);
+        default:
+            return undefined;
+    }
+}
+function getNestedObjectPreview(value, kind) {
+    switch (kind) {
+        case "function":
+            return getFunctionPreview(value);
+        case "array":
+            return withSize(getConstructorName(value) ?? "Array", getArrayLength(value));
+        case "map":
+            return withSize("Map", getMapSize(value));
+        case "set":
+            return withSize("Set", getSetSize(value));
+        case "date":
+            return getDatePreview(value);
+        case "regexp":
+            return truncate(getRegExpText(value), MAX_NESTED_TEXT_LENGTH);
+        case "error":
+            return getConstructorName(value) ?? "Error";
+        default: {
+            const name = getConstructorName(value);
+            return name && name !== "Object" ? name : `{${ELLIPSIS}}`;
+        }
+    }
+}
+function getNestedPreview(value) {
+    try {
+        const kind = getValueKind(value);
+        return (getPrimitivePreview(value, kind, MAX_NESTED_TEXT_LENGTH) ??
+            getNestedObjectPreview(value, kind));
+    }
+    catch (error) {
+        return getUninspectablePreview(getFailureReason(error));
+    }
+}
+function getSourcePreview(source) {
+    switch (source.type) {
+        case "value":
+            return getNestedPreview(source.value);
+        case "getter":
+            return GETTER;
+        case "failure":
+            return getUninspectablePreview(source.reason);
+        case "entry":
+            return `${getNestedPreview(source.key)} => ${getNestedPreview(source.value)}`;
+    }
+}
+function getMemberName(child) {
+    switch (child.step.type) {
+        case "property":
+            return IDENTIFIER.test(child.step.key)
+                ? truncate(child.step.key, MAX_NESTED_TEXT_LENGTH)
+                : quote(child.step.key, MAX_NESTED_TEXT_LENGTH);
+        case "symbol":
+            return truncate(getSymbolText(child.step.key), MAX_NESTED_TEXT_LENGTH);
+        default:
+            return "";
+    }
+}
+function getMembersPreview(children, open, close) {
+    const members = children.slice(0, MAX_MEMBERS).map((child) => {
+        const name = getMemberName(child);
+        const value = getSourcePreview(child.source);
+        return name === "" ? value : `${name}: ${value}`;
+    });
+    if (children.length > members.length) {
+        members.push(ELLIPSIS);
+    }
+    return `${open}${members.join(", ")}${close}`;
+}
+function getContainerPreview(input, value) {
+    const { kind, typeName, children } = input;
+    switch (kind) {
+        case "function":
+            return getFunctionPreview(value);
+        case "date":
+            return getDatePreview(value);
+        case "regexp":
+            return truncate(getRegExpText(value), MAX_TEXT_LENGTH);
+        case "error":
+            return getErrorPreview(value);
+        case "array":
+            return `${withSize(typeName ?? "Array", getArrayLength(value))} ${getMembersPreview(children, "[", "]")}`;
+        case "map":
+            return `${withSize("Map", getMapSize(value))} ${getMembersPreview(children, "{", "}")}`;
+        case "set":
+            return `${withSize("Set", getSetSize(value))} ${getMembersPreview(children, "{", "}")}`;
+        default: {
+            const name = typeName && typeName !== "Object"
+                ? `${truncate(typeName, MAX_NESTED_TEXT_LENGTH)} `
+                : "";
+            return `${name}${getMembersPreview(children, "{", "}")}`;
+        }
+    }
+}
+function getValuePreview(input) {
+    const value = input.source.type === "value" ? input.source.value : undefined;
+    try {
+        return (getPrimitivePreview(value, input.kind, MAX_TEXT_LENGTH) ??
+            getContainerPreview(input, value));
+    }
+    catch (error) {
+        return getUninspectablePreview(getFailureReason(error));
+    }
+}
+function getRawPreview(input) {
+    switch (input.kind) {
+        case "getter":
+            return GETTER;
+        case "uninspectable":
+            return getUninspectablePreview(input.detail);
+        case "circular":
+            return `[Circular ${truncate(input.detail, MAX_TEXT_LENGTH)}]`;
+        case "entry":
+            return getSourcePreview(input.source);
+        default:
+            return getValuePreview(input);
+    }
+}
+export function getPreview(input) {
+    return toSingleLine(getRawPreview(input));
+}

package/dist/ObjectInspector/describe/getValueKind.d.ts

@@ -0,0 +1,2 @@
+export type ValueKind = "string" | "number" | "bigint" | "boolean" | "null" | "undefined" | "symbol" | "function" | "array" | "object" | "map" | "set" | "date" | "regexp" | "error" | "entry" | "getter" | "circular" | "uninspectable";
+export declare function getValueKind(value: unknown): ValueKind;

package/dist/ObjectInspector/describe/getValueKind.js

@@ -0,0 +1,64 @@
+import { getDateTime, getMapSize, getRegExpSource, getSetSize, getTypedArrayLength, } from "./safeRead.js";
+function succeeds(read) {
+    try {
+        read();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isRegExp(value) {
+    return value !== RegExp.prototype && succeeds(() => getRegExpSource(value));
+}
+function isError(value) {
+    const { isError: nativeIsError } = Error;
+    return nativeIsError ? nativeIsError(value) : value instanceof Error;
+}
+function isTypedArray(value) {
+    return (ArrayBuffer.isView(value) && succeeds(() => getTypedArrayLength(value)));
+}
+function hasPlainPrototype(value) {
+    try {
+        const prototype = Reflect.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function getObjectKind(value) {
+    if (Array.isArray(value) || isTypedArray(value)) {
+        return "array";
+    }
+    if (hasPlainPrototype(value)) {
+        return "object";
+    }
+    if (succeeds(() => getMapSize(value))) {
+        return "map";
+    }
+    if (succeeds(() => getSetSize(value))) {
+        return "set";
+    }
+    if (succeeds(() => getDateTime(value))) {
+        return "date";
+    }
+    if (isRegExp(value)) {
+        return "regexp";
+    }
+    if (isError(value)) {
+        return "error";
+    }
+    return "object";
+}
+export function getValueKind(value) {
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "object":
+            return getObjectKind(value);
+        default:
+            return typeof value;
+    }
+}

package/dist/ObjectInspector/describe/safeRead.d.ts

@@ -0,0 +1,12 @@
+export declare const getMapSize: (target: unknown) => number;
+export declare const getSetSize: (target: unknown) => number;
+export declare const getTypedArrayLength: (target: unknown) => number;
+export declare const getRegExpSource: (target: unknown) => string;
+export declare function getDateTime(value: object): number;
+export declare function getRegExpText(value: object): string;
+export declare function getSymbolText(value: symbol): string;
+export declare function isClass(value: object): boolean;
+export declare function getDataProperty(target: object, key: PropertyKey): unknown;
+export declare function getArrayLength(value: unknown): number | undefined;
+export declare function getConstructorName(value: object): string | undefined;
+export declare function getFailureReason(error: unknown): string;

package/dist/ObjectInspector/describe/safeRead.js

@@ -0,0 +1,88 @@
+function nativeGetter(prototype, name) {
+    const get = Object.getOwnPropertyDescriptor(prototype, name)?.get;
+    if (!get) {
+        throw new TypeError(`Missing native getter: ${name}`);
+    }
+    return (target) => get.call(target);
+}
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const getTime = Date.prototype.getTime;
+const functionToString = Function.prototype.toString;
+const symbolToString = Symbol.prototype.toString;
+export const getMapSize = nativeGetter(Map.prototype, "size");
+export const getSetSize = nativeGetter(Set.prototype, "size");
+export const getTypedArrayLength = nativeGetter(typedArrayPrototype, "length");
+export const getRegExpSource = nativeGetter(RegExp.prototype, "source");
+const regExpFlags = [
+    ["d", "hasIndices"],
+    ["g", "global"],
+    ["i", "ignoreCase"],
+    ["m", "multiline"],
+    ["s", "dotAll"],
+    ["u", "unicode"],
+    ["v", "unicodeSets"],
+    ["y", "sticky"],
+].flatMap(([flag, name]) => Object.getOwnPropertyDescriptor(RegExp.prototype, name)?.get
+    ? [[flag, nativeGetter(RegExp.prototype, name)]]
+    : []);
+export function getDateTime(value) {
+    return getTime.call(value);
+}
+export function getRegExpText(value) {
+    const flags = regExpFlags
+        .filter(([, isSet]) => isSet(value))
+        .map(([flag]) => flag)
+        .join("");
+    return `/${getRegExpSource(value)}/${flags}`;
+}
+export function getSymbolText(value) {
+    return symbolToString.call(value);
+}
+export function isClass(value) {
+    return functionToString.call(value).startsWith("class");
+}
+export function getDataProperty(target, key) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+export function getArrayLength(value) {
+    try {
+        if (!Array.isArray(value)) {
+            return undefined;
+        }
+        const length = getDataProperty(value, "length");
+        return typeof length === "number" ? length : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function getConstructorName(value) {
+    const prototype = Reflect.getPrototypeOf(value);
+    if (prototype === null) {
+        return undefined;
+    }
+    const constructor = getDataProperty(prototype, "constructor");
+    if (typeof constructor !== "function") {
+        return undefined;
+    }
+    const name = getDataProperty(constructor, "name");
+    return typeof name === "string" && name !== "" ? name : undefined;
+}
+export function getFailureReason(error) {
+    try {
+        if (typeof error === "string") {
+            return error;
+        }
+        if (typeof error === "object" && error !== null) {
+            const message = getDataProperty(error, "message");
+            if (typeof message === "string" && message !== "") {
+                return message;
+            }
+        }
+    }
+    catch {
+        return "unknown error";
+    }
+    return "unknown error";
+}

package/dist/ObjectInspector/getCopyText.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorNode } from "./describe/describe.js";
+export declare function getCopyText(root: InspectorNode, limit?: number): string;

package/dist/ObjectInspector/getCopyText.js

@@ -0,0 +1,103 @@
+import { getArrayLength } from "./describe/safeRead.js";
+import { getLabelText } from "./getLabelText.js";
+import { getValueText } from "./getValueText.js";
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+const INDENT = "  ";
+const PLAIN_TYPES = new Set(["Object", "Array"]);
+function getPrefix(node, isRoot) {
+    if (isRoot || !node.label || node.label.type === "index") {
+        return "";
+    }
+    const text = getLabelText(node.label);
+    const isPlain = node.label.type !== "property" || IDENTIFIER.test(text);
+    return `${isPlain ? text : JSON.stringify(text)}: `;
+}
+function getLeafText(node) {
+    if (node.kind === "string" && typeof node.value === "string") {
+        return JSON.stringify(node.value);
+    }
+    const length = getListLength(node);
+    if (length !== undefined && length > 0) {
+        return `[${getHoleText(length).slice(0, -1)}]`;
+    }
+    return node.typeName && PLAIN_TYPES.has(node.typeName)
+        ? getOpening(node) + getClosing(node)
+        : node.preview;
+}
+function getOpening(node) {
+    const bracket = node.kind === "array" ? "[" : "{";
+    return node.typeName && !PLAIN_TYPES.has(node.typeName)
+        ? `${node.typeName} ${bracket}`
+        : bracket;
+}
+function getListLength(node) {
+    return node.kind === "array" ? getArrayLength(node.value) : undefined;
+}
+function getHoleText(count) {
+    return `<${count} empty ${count === 1 ? "item" : "items"}>,`;
+}
+function getClosing(node) {
+    return node.kind === "array" ? "]" : "}";
+}
+export function getCopyText(root, limit = 5000) {
+    if (root.childCount === 0) {
+        return root.kind === "string" ? getValueText(root) : getLeafText(root);
+    }
+    const lines = [];
+    const pending = [root];
+    const depths = new Map([[root, 0]]);
+    let remaining = limit;
+    let isCut = false;
+    for (let item = pending.pop(); item !== undefined; item = pending.pop()) {
+        if (typeof item === "string") {
+            lines.push(item);
+            continue;
+        }
+        const depth = depths.get(item) ?? 0;
+        depths.delete(item);
+        const indent = INDENT.repeat(depth);
+        const end = item === root ? "" : ",";
+        if (remaining <= 0) {
+            if (!isCut) {
+                isCut = true;
+                lines.push(`${indent}…`);
+            }
+            continue;
+        }
+        remaining -= 1;
+        const prefix = indent + getPrefix(item, item === root);
+        if (item.childCount === 0) {
+            lines.push(prefix + getLeafText(item) + end);
+            continue;
+        }
+        if (item.childCount > limit) {
+            lines.push(prefix + item.preview + end);
+            continue;
+        }
+        lines.push(prefix + getOpening(item));
+        pending.push(indent + getClosing(item) + end);
+        const children = item.children();
+        const childIndent = INDENT.repeat(depth + 1);
+        const length = getListLength(item);
+        const isList = length !== undefined;
+        let next = length ?? 0;
+        for (let index = children.length - 1; index >= 0; index--) {
+            const child = children[index];
+            if (!child) {
+                continue;
+            }
+            if (isList && child.label?.type === "index") {
+                if (child.label.index + 1 < next) {
+                    pending.push(childIndent + getHoleText(next - child.label.index - 1));
+                }
+                next = child.label.index;
+            }
+            depths.set(child, depth + 1);
+            pending.push(child);
+        }
+        if (isList && next > 0) {
+            pending.push(childIndent + getHoleText(next));
+        }
+    }
+    return lines.join("\n");
+}

package/dist/ObjectInspector/getLabelText.d.ts

@@ -0,0 +1,2 @@
+import type { NodeLabel } from "./describe/describe.js";
+export declare function getLabelText(label: NodeLabel): string;

package/dist/ObjectInspector/getLabelText.js

@@ -0,0 +1,15 @@
+export function getLabelText(label) {
+    switch (label.type) {
+        case "property":
+            return label.key === "" ? '""' : label.key;
+        case "symbol":
+            return Symbol.prototype.toString.call(label.key);
+        case "index":
+        case "entry":
+            return String(label.index);
+        case "entryKey":
+            return "key";
+        case "entryValue":
+            return "value";
+    }
+}

package/dist/ObjectInspector/getValueText.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorNode } from "./describe/describe.js";
+export declare function getValueText(node: InspectorNode): string;

package/dist/ObjectInspector/getValueText.js

@@ -0,0 +1,5 @@
+export function getValueText(node) {
+    return node.kind === "string" && typeof node.value === "string"
+        ? node.value
+        : node.preview;
+}

package/dist/ObjectInspector/search/getHighlightParts.d.ts

@@ -0,0 +1,5 @@
+export interface HighlightPart {
+    readonly text: string;
+    readonly isMatch: boolean;
+}
+export declare function getHighlightParts(text: string, search: string): HighlightPart[];

package/dist/ObjectInspector/search/getHighlightParts.js

@@ -0,0 +1,20 @@
+export function getHighlightParts(text, search) {
+    const query = search.trim().toLocaleLowerCase();
+    const lowered = text.toLocaleLowerCase();
+    if (query === "" || lowered.length !== text.length) {
+        return [{ text, isMatch: false }];
+    }
+    const parts = [];
+    let position = 0;
+    for (let found = lowered.indexOf(query); found >= 0; found = lowered.indexOf(query, position)) {
+        if (found > position) {
+            parts.push({ text: text.slice(position, found), isMatch: false });
+        }
+        position = found + query.length;
+        parts.push({ text: text.slice(found, position), isMatch: true });
+    }
+    if (position < text.length || parts.length === 0) {
+        parts.push({ text: text.slice(position), isMatch: false });
+    }
+    return parts;
+}

package/dist/ObjectInspector/search/getMatches.d.ts

@@ -0,0 +1,6 @@
+import type { InspectorNode } from "../describe/describe.js";
+export interface Matches {
+    readonly ids: readonly string[];
+    readonly isComplete: boolean;
+}
+export declare function getMatches(root: InspectorNode, text: string, limit: number): Matches;

package/dist/ObjectInspector/search/getMatches.js

@@ -0,0 +1,46 @@
+import { getLabelText } from "../getLabelText.js";
+import { getValueText } from "../getValueText.js";
+const NO_MATCHES = { ids: [], isComplete: true };
+function isMatch(node, query) {
+    if (node.label &&
+        getLabelText(node.label).toLocaleLowerCase().includes(query)) {
+        return true;
+    }
+    return (node.childCount === 0 &&
+        getValueText(node).toLocaleLowerCase().includes(query));
+}
+export function getMatches(root, text, limit) {
+    const query = text.trim().toLocaleLowerCase();
+    if (query === "") {
+        return NO_MATCHES;
+    }
+    const ids = [];
+    const pending = [root];
+    let remaining = limit;
+    let isComplete = true;
+    for (let node = pending.pop(); node; node = pending.pop()) {
+        if (remaining <= 0) {
+            isComplete = false;
+            break;
+        }
+        remaining -= 1;
+        if (isMatch(node, query)) {
+            ids.push(node.id);
+        }
+        if (node.childCount === 0) {
+            continue;
+        }
+        if (node.childCount > limit) {
+            isComplete = false;
+            continue;
+        }
+        const children = node.children();
+        for (let index = children.length - 1; index >= 0; index--) {
+            const child = children[index];
+            if (child) {
+                pending.push(child);
+            }
+        }
+    }
+    return { ids, isComplete };
+}

package/dist/ObjectInspector/search/getSearchStatus.d.ts

@@ -0,0 +1,2 @@
+import type { Matches } from "./getMatches.js";
+export declare function getSearchStatus(query: string, matches: Matches, current: number): string;

package/dist/ObjectInspector/search/getSearchStatus.js

@@ -0,0 +1,14 @@
+export function getSearchStatus(query, matches, current) {
+    if (query.trim() === "") {
+        return "";
+    }
+    const count = matches.ids.length;
+    const scope = matches.isComplete ? "" : " in the part that was searched";
+    if (count === 0) {
+        return `No matches${scope}`;
+    }
+    if (current >= 0) {
+        return `${current + 1} of ${count}${scope}`;
+    }
+    return `${count} ${count === 1 ? "match" : "matches"}${scope}`;
+}

package/dist/Tree/Tree.d.ts

@@ -0,0 +1,14 @@
+import { type ComponentProps, type ReactNode } from "react";
+import { type TreeNode, type TreeRow } from "./treeModel.js";
+export interface TreeProps<Node extends TreeNode> extends Omit<ComponentProps<"div">, "children" | "dangerouslySetInnerHTML" | "role" | "aria-label" | "aria-labelledby"> {
+    root: Node;
+    label: string;
+    renderRow: (row: TreeRow<Node>) => ReactNode;
+    getRowText?: (row: TreeRow<Node>) => string;
+    expanded?: ReadonlySet<string>;
+    defaultExpanded?: Iterable<string>;
+    onExpandedChange?: (expanded: ReadonlySet<string>) => void;
+    selected?: string;
+    onSelectedChange?: (selected: string) => void;
+}
+export declare function Tree<Node extends TreeNode>({ root, label, renderRow, getRowText, expanded: controlledExpanded, defaultExpanded, onExpandedChange, selected: controlledSelected, onSelectedChange, className, onKeyDown, onFocus, onBlur, ref, ...props }: TreeProps<Node>): import("react").JSX.Element;