@platecms/delta-smart-text 0.1.0

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@platecms/delta-smart-text",
+  "version": "0.1.0",
+  "description": "Provides a component to display smart text by using slate.",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/startmetplate/delta.git"
+  },
+  "homepage": "https://bitbucket.org/startmetplate/delta/src/dev/packages/delta-smart-text",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./index.css": "./index.css"
+  },
+  "dependencies": {
+    "@fortawesome/free-regular-svg-icons": "6.7.2",
+    "@fortawesome/free-solid-svg-icons": "6.7.2",
+    "@fortawesome/react-fontawesome": "0.2.2",
+    "@platecms/delta-cast": "0.4.8",
+    "@platecms/delta-plate-resource-notation": "1.4.1",
+    "@graphql-codegen/cli": "5.0.3",
+    "@graphql-typed-document-node/core": "3.2.0",
+    "@platecms/delta-cast-util-to-plaintext": "1.0.3",
+    "@reduxjs/toolkit": "2.5.1",
+    "class-transformer": "0.5.1",
+    "graphql": "16.10.0",
+    "is-hotkey": "0.2.0",
+    "lodash": "4.17.21",
+    "prismjs": "1.29.0",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
+    "react-redux": "9.2.0",
+    "redux-watch": "1.2.0",
+    "reflect-metadata": "0.2.2",
+    "slate": "0.112.0",
+    "slate-react": "0.112.1",
+    "tslib": "2.8.1",
+    "uuid": "11.0.5",
+    "vue": "3.5.13",
+    "@vitejs/plugin-vue": "4.5.0",
+    "vite-plugin-dts": "4.5.0",
+    "@tailwindcss/vite": "4.0.6",
+    "@vitejs/plugin-react": "4.3.4",
+    "zwitch": "2.0.4",
+    "@apollo/client": "3.13.1",
+    "@testing-library/react": "^16.3.0",
+    "react-tooltip": "^5.28.1"
+  }
+}

package/react/components/DeltaSlateEditor.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export declare function DeltaSlateEditor({ uuid, context }: {
+    uuid: string;
+    context: HTMLElement | null;
+}): React.ReactElement;
+export default DeltaSlateEditor;

package/react/components/DeltaSlateEditorConnector.d.ts

@@ -0,0 +1,9 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+export declare class DeltaSlateEditorConnector {
+    private readonly root;
+    private readonly uuid;
+    private readonly context;
+    private readonly client;
+    constructor(targetEl: HTMLElement, uuid: string, client: ApolloClient<NormalizedCacheObject>, context: HTMLElement | null);
+    render(): void;
+}

package/react/components/Element.d.ts

@@ -0,0 +1,7 @@
+import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { DeltaElement } from '../types';
+export declare function Element({ attributes, children, element, }: {
+    attributes: HTMLAttributes<HTMLElement>;
+    children: ReactNode;
+    element: DeltaElement;
+}): React.ReactElement;

package/react/components/Leaf.d.ts

@@ -0,0 +1,7 @@
+import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { DeltaLeaf } from '../types';
+export declare function Leaf(props: {
+    attributes: HTMLAttributes<HTMLElement>;
+    leaf: DeltaLeaf;
+    children?: ReactNode;
+}): React.ReactElement;

package/react/components/elements/CodeElement.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { CodeElement as CodeElementType } from '../../types';
+export declare function CodeElement(props: {
+    attributes: HTMLAttributes<HTMLElement>;
+    children: ReactNode;
+    element: CodeElementType;
+}): React.ReactElement;
+export default CodeElement;

package/react/components/elements/ContentValueElement.d.ts

@@ -0,0 +1,8 @@
+import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { ContentValueElement as ContentValueElementType } from '../../types';
+export declare function ContentValueElement({ attributes, children, element, }: {
+    attributes: HTMLAttributes<HTMLElement>;
+    children: ReactNode;
+    element: ContentValueElementType;
+}): React.ReactElement;
+export default ContentValueElement;

package/react/components/inputs/SearchInput.d.ts

@@ -0,0 +1,5 @@
+export declare function SearchInput({ onChange, value, placeholder, }: {
+    onChange: (value: string) => void;
+    value: string;
+    placeholder: string;
+}): React.ReactElement;

package/react/components/menus/ContentAndFormatMenu.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+export declare function ContentAndFormatMenu({ uuid }: {
+    uuid: string;
+}): React.ReactElement | null;

package/react/components/menus/ContentLibraryMenu.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+export declare function ContentLibraryMenu({ uuid }: {
+    uuid: string;
+}): React.ReactElement;

package/react/components/menus/ReusableContentMenu.d.ts

@@ -0,0 +1,3 @@
+export declare function ReusableContentMenu({ uuid }: {
+    uuid: string;
+}): React.ReactElement;

package/react/components/menus/content/ContentItemsMenu.d.ts

@@ -0,0 +1,5 @@
+export declare function ContentItemsMenu({ uuid, prn }: {
+    uuid: string;
+    prn: string;
+}): React.ReactElement;
+export default ContentItemsMenu;

package/react/components/menus/content/ContentTypesMenu.d.ts

@@ -0,0 +1,6 @@
+import { ContentType } from './../../../../../__generated__/graphql';
+export declare function ContentTypesMenu({ onContentTypeClick, }: {
+    uuid: string;
+    onContentTypeClick: (contentType: ContentType) => void;
+}): React.ReactElement;
+export default ContentTypesMenu;

package/react/components/menus/content/partials/ContentFieldMenuItem.d.ts

@@ -0,0 +1,6 @@
+import { default as React, ReactNode } from 'react';
+export declare function ContentFieldMenuItem({ name, children }: {
+    name: string;
+    children?: ReactNode;
+}): React.ReactElement;
+export default ContentFieldMenuItem;

package/react/components/menus/content/partials/ContentValueMenuItem.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { ContentValue } from '../../../../../../__generated__/graphql';
+export declare function ContentValueMenuItem({ contentValue, onClick, }: {
+    contentValue: ContentValue;
+    onClick?: (event: React.MouseEvent) => void;
+}): React.ReactElement;
+export default ContentValueMenuItem;

package/react/components/menus/partials/MenuButton.d.ts

@@ -0,0 +1,8 @@
+import { IconDefinition } from '@fortawesome/free-regular-svg-icons';
+import { default as React, ReactNode } from 'react';
+export declare function MenuButton({ icon, text, onClick, children, }: {
+    icon?: IconDefinition;
+    text: string;
+    onClick?: (event: React.MouseEvent) => void;
+    children?: ReactNode;
+}): React.ReactElement;

package/react/components/menus/partials/MenuContainer.d.ts

@@ -0,0 +1,4 @@
+import { default as React, ReactNode } from 'react';
+export declare function MenuContainer({ children }: {
+    children?: ReactNode;
+}): React.ReactElement;

package/react/components/menus/partials/MenuHeader.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { IconDefinition } from '@fortawesome/free-regular-svg-icons';
+export declare function MenuHeader({ text, icon }: {
+    text: string;
+    icon?: IconDefinition;
+}): React.ReactElement;

package/react/components/toolbar/Toolbar.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export declare function Toolbar({ uuid, context }: {
+    uuid: string;
+    context: HTMLElement | null;
+}): React.ReactElement;
+export default Toolbar;

package/react/components/toolbar/ToolbarBlockButton.d.ts

@@ -0,0 +1,13 @@
+import { default as React, ReactNode } from 'react';
+import { HeadingElement, ListElement } from '../../types';
+import { IconDefinition } from '@fortawesome/free-regular-svg-icons';
+export declare function ToolbarBlockButton({ format, properties, icon, children, }: {
+    format: "code" | "heading" | "list";
+    icon: IconDefinition;
+    properties?: {
+        level?: HeadingElement["level"];
+        ordered?: ListElement["ordered"];
+    };
+    children?: ReactNode;
+}): React.ReactElement;
+export default ToolbarBlockButton;

package/react/components/toolbar/ToolbarHeadingDropdownButton.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare function ToolbarHeadingDropdownButton(): React.ReactElement;

package/react/components/toolbar/ToolbarMarkButton.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { IconDefinition } from '@fortawesome/free-regular-svg-icons';
+declare function ToolbarMarkButton({ format, icon, }: {
+    format: "bold" | "italic" | "strikethrough" | "underline";
+    icon: IconDefinition;
+}): React.ReactElement;
+export default ToolbarMarkButton;

package/react/components/toolbar/content/ContentExtractToolbarButton.d.ts

@@ -0,0 +1,2 @@
+export declare function ContentExtractToolbarButton(): React.ReactElement | null;
+export default ContentExtractToolbarButton;

package/react/components/toolbar/content/ContentLibraryToolbarButton.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare function ContentLibraryToolbarButton({ uuid }: {
+    uuid: string;
+}): React.ReactElement;
+export default ContentLibraryToolbarButton;

package/react/components/toolbar/content/ContentToolbar.d.ts

@@ -0,0 +1,4 @@
+export declare function ContentToolbar({ uuid }: {
+    uuid: string;
+}): React.ReactElement;
+export default ContentToolbar;

package/react/config/hotkeys.d.ts

@@ -0,0 +1,2 @@
+import { DeltaLeaf } from '../types';
+export declare const HOTKEYS: Record<string, keyof Omit<DeltaLeaf, "text">>;

package/react/plugins/index.d.ts

@@ -0,0 +1,3 @@
+import { Editor, NodeEntry, Range } from 'slate';
+export declare function withContentValues(editor: Editor): Editor;
+export declare function decorate([node, path]: NodeEntry): Range[];

package/react/store/editorSlice.d.ts

@@ -0,0 +1,161 @@
+import { BaseSelection, Descendant } from 'slate';
+import { ContentItem, ContentType } from '../../../__generated__/graphql';
+interface EditorSlice {
+    states: EditorState[];
+}
+export interface EditorState {
+    uuid: string;
+    search: string;
+    target: BaseSelection | undefined;
+    initialValue: Descendant[];
+    value: Descendant[];
+    selected: {
+        contentType: string | undefined;
+        contentItem: string | undefined;
+    };
+    options: {
+        contentTypes: ContentType[];
+        contentItems: Record<string, ContentItem[]>;
+    };
+}
+export declare const defaultEditorFieldState: Omit<EditorState, "uuid">;
+declare function selectStates(state: EditorSlice): EditorState[];
+declare function selectStateIndex(state: EditorSlice, uuid: string): number;
+export declare const selectById: import('@reduxjs/toolkit').Selector<{
+    editor: EditorSlice;
+}, EditorState, [uuid: string]> & {
+    unwrapped: ((state: EditorSlice, uuid: string) => EditorState) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: EditorState[], resultFuncArgs_1: number) => EditorState;
+        memoizedResultFunc: ((resultFuncArgs_0: EditorState[], resultFuncArgs_1: number) => EditorState) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => EditorState;
+        dependencies: [typeof selectStates, typeof selectStateIndex];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    };
+}, selectByIdTarget: import('@reduxjs/toolkit').Selector<{
+    editor: EditorSlice;
+}, BaseSelection | undefined, [uuid: string]> & {
+    unwrapped: ((state: EditorSlice, uuid: string) => BaseSelection | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: EditorState) => BaseSelection | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: EditorState) => BaseSelection | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => BaseSelection | undefined;
+        dependencies: [((state: EditorSlice, uuid: string) => EditorState) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: EditorState[], resultFuncArgs_1: number) => EditorState;
+            memoizedResultFunc: ((resultFuncArgs_0: EditorState[], resultFuncArgs_1: number) => EditorState) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => EditorState;
+            dependencies: [typeof selectStates, typeof selectStateIndex];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    };
+}, selectByIdSelected: import('@reduxjs/toolkit').Selector<{
+    editor: EditorSlice;
+}, {
+    contentType: string | undefined;
+    contentItem: string | undefined;
+}, [uuid: string]> & {
+    unwrapped: ((state: EditorSlice, uuid: string) => {
+        contentType: string | undefined;
+        contentItem: string | undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: EditorState) => {
+            contentType: string | undefined;
+            contentItem: string | undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: EditorState) => {
+            contentType: string | undefined;
+            contentItem: string | undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            contentType: string | undefined;
+            contentItem: string | undefined;
+        };
+        dependencies: [((state: EditorSlice, uuid: string) => EditorState) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: EditorState[], resultFuncArgs_1: number) => EditorState;
+            memoizedResultFunc: ((resultFuncArgs_0: EditorState[], resultFuncArgs_1: number) => EditorState) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => EditorState;
+            dependencies: [typeof selectStates, typeof selectStateIndex];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    };
+};
+export declare const setState: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    uuid: string;
+    state?: Partial<Omit<EditorState, "uuid">>;
+    context?: string;
+}, "editor/setState">, setInitialValue: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    uuid: string;
+    initialValue: Descendant[];
+}, "editor/setInitialValue">;
+declare const _default: import('@reduxjs/toolkit').Reducer<EditorSlice>;
+export default _default;

package/react/store/store.d.ts

@@ -0,0 +1,5 @@
+import { Action, Store, ThunkAction } from '@reduxjs/toolkit';
+export declare const store: Store;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+export type AppThunk<ReturnType = void> = ThunkAction<ReturnType, RootState, unknown, Action<string>>;

package/react/types.d.ts

@@ -0,0 +1,55 @@
+import { BaseEditor } from 'slate';
+import { ReactEditor } from 'slate-react';
+import { Root } from '../../../cast/src/index.ts';
+declare module "slate" {
+    interface CustomTypes {
+        Editor: BaseEditor & ReactEditor;
+        Element: DeltaElement;
+        Text: DeltaLeaf;
+    }
+}
+export interface DeltaLeafMarkdown {
+    title?: boolean;
+}
+export type DeltaElement = BlockquoteElement | CodeElement | ContentValueElement | HeadingElement | ListElement | ListItemElement | ParagraphElement;
+export type DeltaLeaf = DeltaLeafMarkdown & {
+    text: string;
+    bold?: true;
+    italic?: true;
+    underline?: true;
+    strikethrough?: true;
+    inlineCode?: true;
+    highlight?: true;
+};
+export interface ParagraphElement {
+    type: "paragraph";
+    children: (ContentValueElement | DeltaLeaf)[];
+}
+export interface HeadingElement {
+    type: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: DeltaLeaf[];
+}
+export interface ListElement {
+    type: "list";
+    ordered: boolean;
+    children: ListItemElement[];
+}
+export interface ListItemElement {
+    type: "listItem";
+    children: DeltaLeaf[];
+}
+export interface BlockquoteElement {
+    type: "blockquote";
+    children: DeltaLeaf[];
+}
+export interface CodeElement {
+    type: "code";
+    children: DeltaLeaf[];
+}
+export interface ContentValueElement {
+    type: "contentValue";
+    prn: string;
+    root: Root | undefined;
+    children: DeltaLeaf[];
+}

package/react/utils/decorator.d.ts

@@ -0,0 +1,15 @@
+import { DeltaLeaf } from '../types';
+export type Decorator<T> = (element: T, decorations: string[]) => string[];
+export type LeafDecorator = Decorator<DeltaLeaf>;
+declare function fontWeight(leaf: DeltaLeaf, decorations: string[]): string[];
+declare function fontSize(leaf: DeltaLeaf, decorations: string[]): string[];
+declare function fontStyle(leaf: DeltaLeaf, decorations: string[]): string[];
+declare function textDecoration(leaf: DeltaLeaf, decorations: string[]): string[];
+export declare class DecoratorBuilder<T extends object> {
+    private readonly element;
+    private readonly decorators;
+    constructor(element: T);
+    add(decorator: Decorator<T>): DecoratorBuilder<T>;
+    build(): (decorations: string[]) => string[];
+}
+export { fontSize, fontWeight, fontStyle, textDecoration };

package/react/utils/index.d.ts

@@ -0,0 +1,15 @@
+import { BaseEditor, Editor } from 'slate';
+import { DeltaLeaf, HeadingElement, ListElement } from '../types';
+import { ReactEditor } from 'slate-react';
+import { default as React } from 'react';
+export declare function hasMark(editor: Editor, format: keyof Omit<DeltaLeaf, "text">): boolean;
+export declare function toggleMark(editor: Editor, format: keyof Omit<DeltaLeaf, "text">): void;
+export declare function isBlockActive(editor: BaseEditor & ReactEditor, format: "code" | "heading" | "list", properties?: {
+    level?: HeadingElement["level"];
+    ordered?: ListElement["ordered"];
+}): boolean;
+export declare function toggleBlock(editor: BaseEditor & ReactEditor, format: "code" | "heading" | "list", properties?: {
+    level?: HeadingElement["level"];
+    ordered?: ListElement["ordered"];
+}): void;
+export declare function useClickOutside(ref: React.RefObject<HTMLElement | null>, callback: () => void): void;