json-edit-react 1.30.1 → 2.0.0-beta.0

package/build/index.d.ts

@@ -1,34 +1,9 @@
-import React$1, { JSX } from 'react';
-
-type BasicObject = {
-    [key: string]: BasicObject | unknown | (BasicObject | unknown)[];
-};
-type BasicArray = (BasicObject | unknown)[];
-type InputObject$1 = BasicObject | BasicArray | unknown;
-declare const extract: (inputObj: InputObject$1, properties: string | number | (string | number)[], fallback?: any) => any;
-
-type Path = (string | number)[];
-
-type BasicType = string | number | boolean | undefined | null | ((...args: unknown[]) => unknown);
-type Value = AssignInput | BasicType;
-type InputObject = {
-    [key: string]: Value;
-};
-type InputArray = Value[];
-type AssignInput = InputObject | InputArray;
-interface AssignOptions {
-    remove?: boolean;
-    noError?: boolean;
-    createNew?: boolean;
-    insert?: boolean;
-    insertBefore?: string | number;
-    insertAfter?: string | number;
-}
-declare const assign: (data: AssignInput, propertyPath: string | Path, newValue: any, options?: AssignOptions) => AssignInput;
+import React$1, { JSX, SVGProps } from 'react';
 
 declare const localisedStrings: {
     ITEM_SINGLE: string;
     ITEMS_MULTIPLE: string;
+    ITEMS_FILTERED: string;
     KEY_NEW: string;
     KEY_SELECT: string;
     NO_KEY_OPTIONS: string;
@@ -37,7 +12,8 @@ declare const localisedStrings: {
     ERROR_UPDATE: string;
     ERROR_DELETE: string;
     ERROR_ADD: string;
-    DEFAULT_STRING: string;
+    ERROR_RENAME: string;
+    ERROR_MOVE: string;
     DEFAULT_NEW_KEY: string;
     SHOW_LESS: string;
     EMPTY_STRING: string;
@@ -45,78 +21,81 @@ declare const localisedStrings: {
     TOOLTIP_EDIT: string;
     TOOLTIP_DELETE: string;
     TOOLTIP_ADD: string;
+    TOOLTIP_OK: string;
+    TOOLTIP_CANCEL: string;
 };
 type LocalisedStrings = typeof localisedStrings;
-type TranslateFunction = (key: keyof LocalisedStrings, customData: NodeData, count?: number) => string;
-
-interface EditState {
-    path?: CollectionKey[];
-    action?: 'accept' | 'cancel';
-}
-interface ExternalTriggers {
-    collapse?: CollapseState | CollapseState[];
-    edit?: EditState;
-}
+type TranslateFunction = (key: keyof LocalisedStrings, customData: NodeData, counts?: number | Record<string, string | number>) => string;
 
 interface CustomNodeData {
-    CustomNode?: React.FC<CustomNodeProps>;
-    CustomWrapper?: React.FC<CustomNodeProps>;
-    CustomKey?: React.FC<CustomKeyProps>;
+    CustomComponent?: React.FC<CustomComponentProps>;
+    CustomWrapperComponent?: React.FC<CustomWrapperProps>;
+    CustomKeyComponent?: React.FC<CustomKeyProps>;
     name?: string;
-    customNodeProps?: Record<string, unknown>;
+    componentProps?: Record<string, unknown>;
     wrapperProps?: Record<string, unknown>;
-    hideKey?: boolean;
+    showKey?: boolean;
     defaultValue?: unknown;
-    showInTypesSelector?: boolean;
+    showInTypeSelector?: boolean;
+    editOnTypeSwitch?: boolean;
     showOnEdit?: boolean;
     showOnView?: boolean;
     showEditTools?: boolean;
     showCollectionWrapper?: boolean;
     passOriginalNode?: boolean;
     renderCollectionAsValue?: boolean;
+    toStandardType?: (value: unknown) => ValueData;
+    fromStandardType?: (value: unknown, nodeData: NodeData, componentProps?: Record<string, unknown>) => unknown;
+}
+
+interface SelectProps {
+    options: string[];
+    value?: string;
+    defaultValue?: string;
+    onChange: (value: string) => void;
+    onKeyDown?: (e: React$1.KeyboardEvent) => void;
+    autoFocus?: boolean;
+    placeholder?: string;
+    name?: string;
+    className?: string;
 }
 
 type JsonData = Record<string, unknown> | Array<unknown> | unknown;
-interface JsonEditorProps {
-    data: JsonData;
-    setData?: (data: JsonData) => void;
+interface JsonEditorProps<T = JsonData> {
+    data: T;
+    setData: (data: T) => void;
     rootName?: string;
-    onUpdate?: UpdateFunction;
-    onEdit?: UpdateFunction;
-    onDelete?: UpdateFunction;
-    onAdd?: UpdateFunction;
-    onChange?: OnChangeFunction;
-    onError?: OnErrorFunction;
+    onUpdate?: UpdateFunction<T>;
+    onChange?: OnChangeFunction<T>;
+    onError?: OnErrorFunction<T>;
     showErrorMessages?: boolean;
-    enableClipboard?: boolean | CopyFunction;
+    showClipboardButton?: boolean;
     theme?: ThemeInput;
-    icons?: IconReplacements;
     className?: string;
     id?: string;
     indent?: number;
-    collapse?: boolean | number | FilterFunction;
+    collapse?: boolean | number | FilterFunction<T>;
     collapseAnimationTime?: number;
-    showCollectionCount?: boolean | 'when-closed';
-    restrictEdit?: boolean | FilterFunction;
-    restrictDelete?: boolean | FilterFunction;
-    restrictAdd?: boolean | FilterFunction;
-    restrictTypeSelection?: boolean | TypeOptions | TypeFilterFunction;
-    restrictDrag?: boolean | FilterFunction;
-    viewOnly?: boolean;
+    showCollectionCount?: boolean | 'when-collapsed' | 'when-collapsed-or-filtered';
+    allowEdit?: boolean | FilterFunction<T>;
+    allowDelete?: boolean | FilterFunction<T>;
+    allowAdd?: boolean | FilterFunction<T>;
+    allowTypeSelection?: boolean | TypeOptions | TypeFilterFunction<T>;
+    allowDrag?: boolean | FilterFunction<T>;
     searchText?: string;
-    searchFilter?: 'key' | 'value' | 'all' | SearchFilterFunction;
+    searchFilter?: 'key' | 'value' | 'all' | SearchFilterFunction<T>;
     searchDebounceTime?: number;
-    keySort?: boolean | CompareFunction;
-    showArrayIndices?: boolean;
-    arrayIndexFromOne?: boolean;
+    sortKeys?: boolean | CompareFunction;
+    showArrayIndexes?: boolean;
+    arrayIndexStart?: number;
     showStringQuotes?: boolean;
     showIconTooltips?: boolean;
-    defaultValue?: string | number | boolean | null | object | DefaultValueFunction;
-    newKeyOptions?: string[] | NewKeyOptionsFunction;
+    defaultValue?: string | number | boolean | null | object | DefaultValueFunction<T>;
+    newKeyOptions?: string[] | NewKeyOptionsFunction<T>;
     minWidth?: string | number;
     maxWidth?: string | number;
-    rootFontSize?: string | number;
-    stringTruncate?: number;
+    baseFontSize?: string | number;
+    stringTruncateLength?: number;
     translations?: Partial<LocalisedStrings>;
     customNodeDefinitions?: CustomNodeDefinition<Record<string, any>, Record<string, any>>[];
     customText?: CustomTextDefinitions;
@@ -124,14 +103,33 @@ interface JsonEditorProps {
     jsonParse?: (input: string, reviver?: (key: string, value: string) => unknown) => JsonData;
     jsonStringify?: (input: JsonData, replacer?: (key: string, value: unknown) => unknown) => string;
     TextEditor?: React.FC<TextEditorProps>;
-    errorMessageTimeout?: number;
+    Select?: React.ComponentType<SelectProps>;
+    errorDisplayTime?: number;
     keyboardControls?: KeyboardControls;
     insertAtTop?: boolean | 'array' | 'object';
     collapseClickZones?: Array<'left' | 'header' | 'property'>;
     onEditEvent?: OnEditEventFunction;
     onCollapse?: OnCollapseFunction;
-    externalTriggers?: ExternalTriggers;
+    onCopy?: OnCopyFunction<T>;
+    editorRef?: React.Ref<JsonEditorHandle>;
+}
+interface StartEditOptions {
+    path: CollectionKey[];
+    overrideRestrictions?: boolean;
+}
+type StartEditResult = true | 'RESTRICTED' | 'PATH_NOT_FOUND';
+interface JsonEditorHandle {
+    collapse: (state: CollapseState | CollapseState[]) => void;
+    startEdit: (options: StartEditOptions) => StartEditResult;
+    confirm: () => void;
+    cancel: () => void;
 }
+type JsonViewerHandle = Pick<JsonEditorHandle, 'collapse'>;
+type JsonViewerProps<T = JsonData> = Omit<JsonEditorProps<T>, 'setData' | 'onUpdate' | 'onChange' | 'allowEdit' | 'allowAdd' | 'allowDelete' | 'allowDrag' | 'allowTypeSelection' | 'editorRef'> & {
+    editorRef?: React.Ref<JsonViewerHandle>;
+};
+declare const valueDataTypes: readonly ["string", "number", "boolean", "null"];
+declare const collectionDataTypes: readonly ["object", "array"];
 declare const standardDataTypes: readonly ["string", "number", "boolean", "null", "object", "array"];
 type DataType = (typeof standardDataTypes)[number] | 'invalid';
 type CollectionKey = string | number;
@@ -143,147 +141,182 @@ interface EnumDefinition {
 }
 type TypeOptions = Array<DataType | string | EnumDefinition>;
 type ErrorString = string;
-interface IconReplacements {
-    add?: JSX.Element;
-    edit?: JSX.Element;
-    delete?: JSX.Element;
-    copy?: JSX.Element;
-    ok?: JSX.Element;
-    cancel?: JSX.Element;
-    chevron?: JSX.Element;
-}
+type EditOperation = 'edit' | 'rename' | 'add' | 'delete' | 'move';
 interface TextEditorProps {
     value: string;
     onChange: (value: string) => void;
     onKeyDown: (e: React.KeyboardEvent) => void;
 }
-interface UpdateFunctionProps {
-    newData: JsonData;
-    currentData: JsonData;
+type JerErrorCode = 'UPDATE_ERROR' | 'ADD_ERROR' | 'DELETE_ERROR' | 'RENAME_ERROR' | 'MOVE_ERROR' | 'KEY_EXISTS' | 'INVALID_JSON' | 'CLIPBOARD_ERROR';
+interface JerError {
+    code: JerErrorCode;
+    message: string;
+}
+type UpdateResult<T = JsonData> = true | void | undefined | false | null | {
+    value?: unknown;
+    data?: T;
+    error?: string | JerError;
+};
+type UpdateFunctionProps<T = JsonData> = NodeData<T> & {
+    newData: T;
+} & ({
+    event: 'edit';
     newValue: unknown;
-    currentValue: unknown;
-    name: CollectionKey;
-    path: CollectionKey[];
+} | {
+    event: 'add';
+    newValue: unknown;
+} | {
+    event: 'delete';
+} | {
+    event: 'rename';
+    newKey: string;
+} | {
+    event: 'move';
+    newPath: CollectionKey[];
+});
+interface UpdateControl {
+    hold: () => () => void;
 }
-type UpdateFunctionReturn = ['error' | 'value', JsonData];
-type UpdateFunction = (props: UpdateFunctionProps) => void | ErrorString | boolean | UpdateFunctionReturn | Promise<boolean | ErrorString | void | UpdateFunctionReturn>;
-type OnChangeFunction = (props: {
-    currentData: JsonData;
+type UpdateFunction<T = JsonData> = (props: UpdateFunctionProps<T>, control: UpdateControl) => UpdateResult<T> | Promise<UpdateResult<T>>;
+type OnChangeFunction<T = JsonData> = (props: NodeData<T> & {
     newValue: ValueData;
-    currentValue: ValueData;
-    name: CollectionKey;
-    path: CollectionKey[];
 }) => ValueData;
-interface JerError {
-    code: 'UPDATE_ERROR' | 'DELETE_ERROR' | 'ADD_ERROR' | 'INVALID_JSON' | 'KEY_EXISTS';
-    message: ErrorString;
-}
-type OnErrorFunction = (props: {
-    currentData: JsonData;
-    errorValue: JsonData;
-    currentValue: JsonData;
-    name: CollectionKey;
-    path: CollectionKey[];
+type OnErrorFunction<T = JsonData> = (props: NodeData<T> & {
     error: JerError;
-}) => unknown;
-type FilterFunction = (input: NodeData) => boolean;
-type TypeFilterFunction = (input: NodeData) => boolean | TypeOptions;
-type CustomTextFunction = (input: NodeData) => string | null;
-type DefaultValueFunction = (input: NodeData, newKey?: string) => unknown;
-type SearchFilterFunction = (inputData: NodeData, searchText: string) => boolean;
-type NewKeyOptionsFunction = (input: NodeData) => string[] | null | void;
+    errorValue: JsonData;
+}) => void;
+type FilterFunction<T = JsonData> = (input: NodeData<T>) => boolean;
+type TypeFilterFunction<T = JsonData> = (input: NodeData<T>) => boolean | TypeOptions;
+type CustomTextFunction<T = JsonData> = (input: NodeData<T>) => string | null;
+type DefaultValueFunction<T = JsonData> = (input: NodeData<T>, newKey?: string) => unknown;
+type SearchFilterFunction<T = JsonData> = (inputData: NodeData<T>, searchText: string) => boolean;
+type NewKeyOptionsFunction<T = JsonData> = (input: NodeData<T>) => string[] | null | void;
 type CopyType = 'path' | 'value';
-type CopyFunction = (input: {
+type OnCopyFunction<T = JsonData> = (props: NodeData<T> & {
     success: boolean;
-    errorMessage: string | null;
-    key: CollectionKey;
-    path: CollectionKey[];
-    value: unknown;
     stringValue: string;
     type: CopyType;
+    error?: JerError;
 }) => void;
 type CompareFunction = (a: [string | number, unknown], b: [string | number, unknown]) => number;
 type SortFunction = <T>(arr: T[], nodeMap: (input: T) => [string | number, unknown]) => void;
-type OnEditEventFunction = (path: (CollectionKey | null)[] | null, isKey: boolean) => void;
+type EditEvent<T = JsonData> = NodeData<T> & ({
+    event: 'startEdit';
+} | {
+    event: 'submitEdit';
+} | {
+    event: 'commitEdit';
+} | {
+    event: 'cancelEdit';
+} | {
+    event: 'startRename';
+} | {
+    event: 'submitRename';
+} | {
+    event: 'commitRename';
+    oldKey: CollectionKey;
+    newKey: CollectionKey;
+} | {
+    event: 'cancelRename';
+} | {
+    event: 'startAdd';
+} | {
+    event: 'submitAdd';
+} | {
+    event: 'commitAdd';
+} | {
+    event: 'cancelAdd';
+} | {
+    event: 'delete';
+} | {
+    event: 'move';
+} | {
+    event: 'updateSuccess';
+    operation: EditOperation;
+} | {
+    event: 'updateError';
+    operation: EditOperation;
+    error: JerError;
+});
+type OnEditEventFunction<T = JsonData> = (e: EditEvent<T>) => void;
 interface CollapseState {
     path: CollectionKey[];
     collapsed: boolean;
     includeChildren: boolean;
 }
-type OnCollapseFunction = (input: CollapseState) => void;
-type InternalUpdateFunction = (value: unknown, path: CollectionKey[], options?: AssignOptions) => Promise<string | void>;
-type Position = 'above' | 'below';
-type InternalMoveFunction = (source: CollectionKey[] | null, dest: CollectionKey[], position: Position) => Promise<string | void>;
+type OnCollapseFunction<T = JsonData> = (props: NodeData<T> & {
+    collapsed: boolean;
+    includeChildren: boolean;
+}) => void;
 interface KeyEvent {
     key: string;
     modifier?: React.ModifierKey | React.ModifierKey[];
 }
 interface KeyboardControls {
-    confirm?: KeyEvent | string;
-    cancel?: KeyEvent | string;
-    objectConfirm?: KeyEvent | string;
-    objectLineBreak?: KeyEvent | string;
-    stringConfirm?: KeyEvent | string;
-    stringLineBreak?: KeyEvent | string;
-    booleanConfirm?: KeyEvent | string;
-    booleanToggle?: KeyEvent | string;
-    numberConfirm?: KeyEvent | string;
-    numberUp?: KeyEvent | string;
-    numberDown?: KeyEvent | string;
-    tabForward?: KeyEvent | string;
-    tabBack?: KeyEvent | string;
-    clipboardModifier?: React.ModifierKey | React.ModifierKey[];
-    collapseModifier?: React.ModifierKey | React.ModifierKey[];
+    confirm?: KeyEvent | string | null;
+    cancel?: KeyEvent | string | null;
+    objectConfirm?: KeyEvent | string | null;
+    objectLineBreak?: KeyEvent | string | null;
+    stringConfirm?: KeyEvent | string | null;
+    stringLineBreak?: KeyEvent | string | null;
+    booleanConfirm?: KeyEvent | string | null;
+    booleanToggle?: KeyEvent | string | null;
+    numberConfirm?: KeyEvent | string | null;
+    numberUp?: KeyEvent | string | null;
+    numberDown?: KeyEvent | string | null;
+    tabForward?: KeyEvent | string | null;
+    tabBack?: KeyEvent | string | null;
+    clipboardModifier?: React.ModifierKey | React.ModifierKey[] | null;
+    collapseModifier?: React.ModifierKey | React.ModifierKey[] | null;
 }
 type KeyboardControlsFull = Omit<Required<{
-    [Property in keyof KeyboardControls]: KeyEvent;
+    [Property in keyof KeyboardControls]: KeyEvent | null;
 }>, 'clipboardModifier' | 'collapseModifier'> & {
     clipboardModifier: React.ModifierKey[];
     collapseModifier: React.ModifierKey[];
 };
-interface NodeData {
+interface NodeData<T = JsonData> {
     key: CollectionKey;
     path: CollectionKey[];
     level: number;
     index: number;
     value: JsonData;
     size: number | null;
+    visibleSize?: number | null;
     parentData: object | null;
-    fullData: JsonData;
+    fullData: T;
     collapsed?: boolean;
 }
 interface BaseNodeProps {
     data: unknown;
     parentData: CollectionData | null;
     nodeData: NodeData;
-    onEdit: InternalUpdateFunction;
-    onDelete: InternalUpdateFunction;
+    getLatestData: () => JsonData;
     onError?: OnErrorFunction;
     showErrorMessages: boolean;
     showIconTooltips: boolean;
-    onMove: InternalMoveFunction;
-    enableClipboard: boolean | CopyFunction;
+    showClipboardButton: boolean;
+    onCopy?: OnCopyFunction;
     onEditEvent?: OnEditEventFunction;
-    restrictEditFilter: FilterFunction;
-    restrictDeleteFilter: FilterFunction;
-    restrictAddFilter: FilterFunction;
-    restrictDragFilter: FilterFunction;
+    allowEditFilter: FilterFunction;
+    allowDeleteFilter: FilterFunction;
+    allowAddFilter: FilterFunction;
+    allowDragFilter: FilterFunction;
     canDragOnto: boolean;
-    searchFilter?: SearchFilterFunction;
-    searchText?: string;
-    restrictTypeSelection: boolean | TypeOptions | TypeFilterFunction;
-    stringTruncate: number;
+    allowTypeSelection: boolean | TypeOptions | TypeFilterFunction;
+    stringTruncateLength: number;
     indent: number;
-    arrayIndexFromOne: boolean;
+    arrayIndexStart: number;
     sort: SortFunction;
     translate: TranslateFunction;
     customNodeDefinitions: CustomNodeDefinition[];
     customNodeData: CustomNodeData;
     customButtons: CustomButtonDefinition[];
-    errorMessageTimeout: number;
+    Select: React.ComponentType<SelectProps>;
+    errorDisplayTime: number;
     keyboardControls: KeyboardControlsFull;
     handleKeyboard: (e: React.KeyboardEvent, eventMap: Partial<Record<keyof KeyboardControlsFull, () => void>>) => void;
-    editConfirmRef: React.RefObject<HTMLDivElement | null>;
+    editConfirmRef: React.RefObject<HTMLButtonElement | null>;
     jsonStringify: (data: JsonData, replacer?: (this: any, key: string, value: unknown) => string) => string;
 }
 interface CollectionNodeProps extends BaseNodeProps {
@@ -291,9 +324,8 @@ interface CollectionNodeProps extends BaseNodeProps {
     data: CollectionData;
     collapseFilter: FilterFunction;
     collapseAnimationTime: number;
-    onAdd: InternalUpdateFunction;
-    showArrayIndices: boolean;
-    showCollectionCount: boolean | 'when-closed';
+    showArrayIndexes: boolean;
+    showCollectionCount: boolean | 'when-collapsed' | 'when-collapsed-or-filtered';
     showStringQuotes: boolean;
     defaultValue: unknown;
     newKeyOptions?: string[] | NewKeyOptionsFunction;
@@ -319,21 +351,22 @@ interface CustomKeyProps<T = Record<string, unknown>> {
     path: CollectionKey[];
     canEditKey: boolean;
     handleEditKey: (newKey: string) => void;
-    setIsEditingKey: () => void;
+    startEditingKey: () => void;
     handleClick?: (e: React.MouseEvent) => void;
     styles: React.CSSProperties;
-    customNodeProps?: T;
+    componentProps?: T;
     getStyles: (element: ThemeableElement, nodeData: NodeData) => React.CSSProperties;
 }
-interface CustomNodeProps<T = Record<string, unknown>> extends Omit<BaseNodeProps, 'onError'> {
+interface CustomComponentProps<T = Record<string, unknown>> extends Omit<BaseNodeProps, 'onError' | 'data'> {
     value: JsonData;
-    customNodeProps?: T;
+    componentProps?: T;
     parentData: CollectionData | null;
-    setValue: (value: ValueData) => void;
+    setValue: (value: JsonData) => void;
     handleEdit: (value?: unknown) => void;
     handleCancel: () => void;
-    handleKeyPress: (e: React.KeyboardEvent) => void;
+    onKeyDown: (e: React.KeyboardEvent) => void;
     isEditing: boolean;
+    isPending: boolean;
     setIsEditing: React.Dispatch<React.SetStateAction<boolean>>;
     getStyles: (element: ThemeableElement, nodeData: NodeData) => React.CSSProperties;
     children?: JSX.Element | JSX.Element[] | null;
@@ -341,27 +374,32 @@ interface CustomNodeProps<T = Record<string, unknown>> extends Omit<BaseNodeProp
     originalNodeKey?: JSX.Element;
     canEdit: boolean;
     keyboardCommon: Partial<Record<keyof KeyboardControlsFull, () => void>>;
-    onError: (error: JerError, errorValue: JsonData | string) => void;
+}
+interface CustomWrapperProps<U = Record<string, unknown>> extends Omit<CustomComponentProps, 'componentProps'> {
+    wrapperProps?: U;
 }
 interface CustomNodeDefinition<T = Record<string, unknown>, U = Record<string, unknown>> {
     condition: FilterFunction;
-    element?: React.FC<CustomNodeProps<T>>;
-    customKey?: React.FC<CustomKeyProps<T>>;
+    component?: React.FC<CustomComponentProps<T>>;
+    keyComponent?: React.FC<CustomKeyProps<T>>;
     name?: string;
-    customNodeProps?: T;
-    hideKey?: boolean;
+    componentProps?: T;
+    showKey?: boolean;
     defaultValue?: unknown;
-    showInTypesSelector?: boolean;
+    showInTypeSelector?: boolean;
     showOnEdit?: boolean;
     showOnView?: boolean;
+    editOnTypeSwitch?: boolean;
     showEditTools?: boolean;
     passOriginalNode?: boolean;
     showCollectionWrapper?: boolean;
-    wrapperElement?: React.FC<CustomNodeProps<U>>;
-    wrapperProps?: Record<string, unknown>;
+    wrapperComponent?: React.FC<CustomWrapperProps<U>>;
+    wrapperProps?: U;
     renderCollectionAsValue?: boolean;
     stringifyReplacer?: (value: unknown) => unknown;
     parseReviver?: (stringified: string) => unknown;
+    toStandardType?: (value: unknown) => ValueData;
+    fromStandardType?: (value: unknown, nodeData: NodeData, componentProps?: T) => unknown;
 }
 type CustomTextDefinitions = Partial<{
     [key in keyof LocalisedStrings]: CustomTextFunction;
@@ -372,41 +410,49 @@ interface CustomButtonDefinition {
     }>;
     onClick: (nodeData: NodeData, e: React.MouseEvent) => void;
 }
-type ThemeInput = Theme | Partial<ThemeStyles> | Array<Theme | Partial<ThemeStyles>>;
-type ThemeableElement = 'container' | 'collection' | 'collectionInner' | 'collectionElement' | 'dropZone' | 'property' | 'bracket' | 'itemCount' | 'string' | 'number' | 'boolean' | 'null' | 'input' | 'inputHighlight' | 'error' | 'iconCollection' | 'iconEdit' | 'iconDelete' | 'iconAdd' | 'iconCopy' | 'iconOk' | 'iconCancel';
-type ThemeFunction = (nodeData: NodeData) => React.CSSProperties | null | undefined;
-type ThemeValue = string | React.CSSProperties | Array<string | React.CSSProperties | ThemeFunction> | ThemeFunction;
-type ThemeStyles = Record<ThemeableElement, ThemeValue>;
-type Fragments = Record<string, React.CSSProperties | string>;
+type ThemeableElement = 'container' | 'collection' | 'collectionElement' | 'headerRow' | 'valueRow' | 'dropZone' | 'property' | 'bracket' | 'itemCount' | 'string' | 'number' | 'boolean' | 'null' | 'input' | 'inputHighlight' | 'error' | 'iconCollection' | 'iconEdit' | 'iconDelete' | 'iconAdd' | 'iconCopy' | 'iconOk' | 'iconCancel';
+type StyleFunction = (nodeData: NodeData) => React.CSSProperties | null | undefined;
+type ThemeValueUnit = string | React.CSSProperties | StyleFunction;
+type ThemeElementValue = ThemeValueUnit | ThemeValueUnit[];
+type ThemeFragments = Record<string, string | React.CSSProperties>;
+type ThemeStyles = Partial<Record<Exclude<ThemeableElement, 'inputHighlight'>, ThemeElementValue>> & {
+    inputHighlight?: string;
+};
+interface IconDefinition {
+    content: React.ReactNode;
+    viewBox?: string;
+    svgProps?: React.SVGProps<SVGSVGElement>;
+    scale?: number;
+}
+interface ThemeIcons {
+    add?: IconDefinition;
+    edit?: IconDefinition;
+    delete?: IconDefinition;
+    copy?: IconDefinition;
+    ok?: IconDefinition;
+    cancel?: IconDefinition;
+    collection?: IconDefinition;
+}
 interface Theme {
     displayName?: string;
-    fragments?: Fragments;
-    styles: Partial<ThemeStyles>;
+    fragments?: ThemeFragments;
+    icons?: ThemeIcons;
+    styles: ThemeStyles;
 }
+type ThemeInput = Theme | ThemeStyles | Array<Theme | ThemeStyles>;
 
-declare const JsonEditor: React$1.FC<JsonEditorProps>;
+declare function JsonEditor<T = JsonData>(props: JsonEditorProps<T>): React$1.ReactElement;
 
-declare const defaultTheme: Theme;
+declare function JsonViewer<T = JsonData>(props: JsonViewerProps<T>): React$1.ReactElement | null;
 
-interface IconProps {
-    size: string;
-    style?: React$1.CSSProperties;
-    className?: string;
-}
-declare const IconAdd: React$1.FC<IconProps>;
-declare const IconEdit: React$1.FC<IconProps>;
-declare const IconDelete: React$1.FC<IconProps>;
-declare const IconCopy: React$1.FC<IconProps>;
-declare const IconOk: React$1.FC<IconProps>;
-declare const IconCancel: React$1.FC<IconProps>;
-declare const IconChevron: React$1.FC<IconProps>;
+declare const defaultTheme: Theme;
 
 interface StringDisplayProps {
     nodeData: NodeData;
     styles: React$1.CSSProperties;
     pathString: string;
     showStringQuotes?: boolean;
-    stringTruncate?: number;
+    stringTruncateLength?: number;
     canEdit: boolean;
     setIsEditing: (value: React$1.SetStateAction<boolean>) => void;
     translate: TranslateFunction;
@@ -428,24 +474,53 @@ interface StringEditProps {
 declare const StringEdit: React$1.FC<StringEditProps>;
 declare const useKeyboardListener: (isEditing: boolean, listener: (e: unknown) => void) => void;
 
-declare const LinkCustomComponent: React$1.FC<CustomNodeProps<{
-    stringTruncate?: number;
-}> & ValueNodeProps>;
-declare const LinkCustomNodeDefinition: CustomNodeDefinition;
+interface TextAreaProps {
+    className: string;
+    name: string;
+    value: string;
+    setValue: React$1.Dispatch<React$1.SetStateAction<string>>;
+    onKeyDown: (e: React$1.KeyboardEvent) => void;
+    styles: React$1.CSSProperties;
+    textAreaRef?: React$1.MutableRefObject<HTMLTextAreaElement | null>;
+}
+declare const AutogrowTextArea: React$1.FC<TextAreaProps>;
+
+declare const IconSvg: ({ scale, viewBox, fill, children, ...props }: {
+    scale?: number;
+} & Omit<SVGProps<SVGSVGElement>, "scale">) => JSX.Element;
 
-declare const isCollection: (value: unknown) => value is Record<string, unknown> | unknown[];
 declare const matchNode: (input: Partial<NodeData>, searchText: string) => boolean;
 declare const matchNodeKey: SearchFilterFunction;
-declare const toPathString: (path: Array<string | number>, key?: "key_") => string;
 
-declare const githubDarkTheme: Theme;
-declare const githubLightTheme: Theme;
-declare const monoDarkTheme: Theme;
-declare const monoLightTheme: Theme;
-declare const candyWrapperTheme: Theme;
-declare const psychedelicTheme: Theme;
+declare const isCollection: (value: unknown) => value is Record<string, unknown> | unknown[];
+
+type Path = (string | number)[];
+declare const splitPropertyString: (propertyPath: string) => Path;
+declare const toPathString: (path: CollectionKey[]) => string;
+
+type BasicType = string | number | boolean | undefined | null | ((...args: unknown[]) => unknown);
+type Value = AssignInput | BasicType;
+type InputObject$1 = {
+    [key: string]: Value;
+};
+type InputArray = Value[];
+type AssignInput = InputObject$1 | InputArray;
+interface AssignOptions {
+    remove?: boolean;
+    noError?: boolean;
+    createNew?: boolean;
+    insert?: boolean;
+    insertBefore?: string | number;
+    insertAfter?: string | number;
+}
+declare const assign: (data: AssignInput, propertyPath: string | Path, newValue: any, options?: AssignOptions) => AssignInput;
 
-export { IconAdd, IconCancel, IconChevron, IconCopy, IconDelete, IconEdit, IconOk, JsonEditor, LinkCustomComponent, LinkCustomNodeDefinition, StringDisplay, StringEdit, assign, candyWrapperTheme, defaultTheme, extract, githubDarkTheme, githubLightTheme, isCollection, matchNode, matchNodeKey, monoDarkTheme, monoLightTheme, psychedelicTheme, standardDataTypes, toPathString, useKeyboardListener };
+type BasicObject = {
+    [key: string]: BasicObject | unknown | (BasicObject | unknown)[];
+};
+type BasicArray = (BasicObject | unknown)[];
+type InputObject = BasicObject | BasicArray | unknown;
+declare const extract: (inputObj: InputObject, properties: string | number | (string | number)[], fallback?: any) => any;
 
-// Types
-export { AssignInput, AssignOptions, CollapseState, CollectionNodeProps, CompareFunction, CopyFunction, CustomKeyProps, CustomNodeDefinition, CustomNodeProps, CustomTextDefinitions, CustomTextFunction, DataType, DefaultValueFunction, EditState, EnumDefinition, ErrorString, ExternalTriggers, FilterFunction, IconProps, IconReplacements, JerError, JsonData, JsonEditorProps, KeyboardControls, LocalisedStrings, NewKeyOptionsFunction, NodeData, OnChangeFunction, OnCollapseFunction, OnEditEventFunction, OnErrorFunction, SearchFilterFunction, TextEditorProps, Theme, ThemeInput, ThemeStyles, TranslateFunction, TypeFilterFunction, TypeOptions, UpdateFunction, UpdateFunctionProps, ValueNodeProps };
+export { AutogrowTextArea, IconSvg, JsonEditor, JsonViewer, StringDisplay, StringEdit, assign, collectionDataTypes, defaultTheme, extract, isCollection, matchNode, matchNodeKey, splitPropertyString, standardDataTypes, toPathString, useKeyboardListener, valueDataTypes };
+export type { AssignInput, AssignOptions, CollapseState, CollectionNodeProps, CompareFunction, CustomButtonDefinition, CustomComponentProps, CustomKeyProps, CustomNodeDefinition, CustomTextDefinitions, CustomTextFunction, CustomWrapperProps, DataType, DefaultValueFunction, EditEvent, EnumDefinition, ErrorString, FilterFunction, IconDefinition, JerError, JerErrorCode, JsonData, JsonEditorHandle, JsonEditorProps, JsonViewerHandle, JsonViewerProps, KeyboardControls, LocalisedStrings, NewKeyOptionsFunction, NodeData, OnChangeFunction, OnCollapseFunction, OnCopyFunction, OnEditEventFunction, OnErrorFunction, SearchFilterFunction, SelectProps, StartEditOptions, StartEditResult, TextEditorProps, Theme, ThemeIcons, ThemeInput, ThemeStyles, TranslateFunction, TypeFilterFunction, TypeOptions, UpdateFunction, UpdateFunctionProps, UpdateResult, ValueNodeProps };