@akinon/ui-editor 1.0.0

package/dist/cjs/tiptap/utils/highlight-html.js

@@ -0,0 +1,82 @@
+/**
+ * Simple HTML syntax highlighter without external dependencies
+ * Tokenizes HTML and wraps tokens in spans for styling
+ */
+const CLASSES = {
+    COMMENT: 'html-comment',
+    DOCTYPE: 'html-doctype',
+    TAG: 'html-tag',
+    ATTR: 'html-attr',
+    VALUE: 'html-value',
+    STRING: 'html-string'
+};
+const REGEX = {
+    // Matches HTML tags, comments, doctypes
+    TOKEN: /((?:<!--[\s\S]*?-->)|(?:<!DOCTYPE[^>]*>)|(?:<\/?[\w-]+(?:(?:\s+[\w-]+(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*\s*)\/?>))/gi,
+    COMMENT: /^<!--/,
+    DOCTYPE: /^<!DOCTYPE/i,
+    TAG_START: /^<\/?/,
+    // parse tag: 1=openBracket, 2=tagName, 3=attributes, 4=closeBracket
+    TAG_PARSE: /(&lt;\/?)([\w-]+)((?:\s+[\w-]+(?:=(?:"[^"]*"|'[^']*'|[^\s&gt;]*))?)*\s*)(\/?&gt;)/g,
+    // parse attributes: 1=name, 2=equals, 3=fullValue, 4=doubleQ, 5=singleQ, 6=unquoted
+    // parse attributes: 1=name, 2=equals, 3=fullValue, 4=doubleQ, 5=singleQ, 6=unquoted
+    ATTR_PARSE: /([\w-]+)(?:(=)("([^"]*)"|'([^']*)'|([^\s>]*)))?/g,
+    STRING_LITERAL: /(".*?"|'.*?')/g
+};
+export const highlightHtml = (html) => {
+    const tokens = html.split(REGEX.TOKEN);
+    return tokens.map(processToken).join('');
+};
+const processToken = (token) => {
+    if (REGEX.COMMENT.test(token)) {
+        return wrapInSpan(escapeHtml(token), CLASSES.COMMENT);
+    }
+    if (REGEX.DOCTYPE.test(token)) {
+        return wrapInSpan(escapeHtml(token), CLASSES.DOCTYPE);
+    }
+    if (REGEX.TAG_START.test(token)) {
+        return processTag(token);
+    }
+    return processText(token);
+};
+const processTag = (token) => {
+    const escapedToken = escapeHtml(token);
+    return escapedToken.replace(REGEX.TAG_PARSE, (_, openBracket, tagName, attributes, closeBracket) => {
+        let result = `${openBracket}${wrapInSpan(tagName, CLASSES.TAG)}`;
+        if (attributes) {
+            result += processAttributes(attributes);
+        }
+        result += closeBracket;
+        return result;
+    });
+};
+const processAttributes = (attributes) => {
+    return attributes.replace(REGEX.ATTR_PARSE, (_match, attrName, equals, _fullValue, doubleQuoted, singleQuoted, unquoted) => {
+        const nameSpan = wrapInSpan(attrName, CLASSES.ATTR);
+        if (!equals) {
+            return nameSpan;
+        }
+        let formattedValue = '';
+        if (doubleQuoted !== undefined) {
+            formattedValue = `"${doubleQuoted}"`;
+        }
+        else if (singleQuoted !== undefined) {
+            formattedValue = `'${singleQuoted}'`;
+        }
+        else {
+            formattedValue = unquoted || '';
+        }
+        const valueSpan = wrapInSpan(formattedValue, CLASSES.VALUE);
+        return `${nameSpan}${equals}${valueSpan}`;
+    });
+};
+const processText = (token) => {
+    const escaped = escapeHtml(token);
+    return escaped.replace(REGEX.STRING_LITERAL, match => `<span class="${CLASSES.STRING}">${match}</span>`);
+};
+const escapeHtml = (str) => {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+};
+const wrapInSpan = (content, className) => {
+    return `<span class="${className}">${content}</span>`;
+};

package/dist/cjs/tiptap/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './format-html';
+export * from './highlight-html';
+export * from './normalize-html';
+export * from './tiptap-extensions';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/tiptap/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tiptap/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC"}

package/dist/cjs/tiptap/utils/index.js

@@ -0,0 +1,4 @@
+export * from './format-html';
+export * from './highlight-html';
+export * from './normalize-html';
+export * from './tiptap-extensions';

package/dist/cjs/tiptap/utils/normalize-html.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normalizes HTML by removing formatting whitespace (newlines and indentation)
+ * while preserving meaningful whitespace within text content.
+ * Used when converting from source mode back to visual editor.
+ */
+export declare const normalizeHtml: (html: string) => string;
+//# sourceMappingURL=normalize-html.d.ts.map

package/dist/cjs/tiptap/utils/normalize-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-html.d.ts","sourceRoot":"","sources":["../../../../src/tiptap/utils/normalize-html.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAY5C,CAAC"}

package/dist/cjs/tiptap/utils/normalize-html.js

@@ -0,0 +1,109 @@
+import { HTML_ELEMENTS } from '../constants';
+/**
+ * Normalizes HTML by removing formatting whitespace (newlines and indentation)
+ * while preserving meaningful whitespace within text content.
+ * Used when converting from source mode back to visual editor.
+ */
+export const normalizeHtml = (html) => {
+    const div = document.createElement(HTML_ELEMENTS.DIV);
+    div.innerHTML = html;
+    cleanScriptsAndStyles(div);
+    convertCommentsToSpans(div);
+    unwrapHrFromParagraphs(div);
+    flattenEmptyParagraphs(div);
+    mergeConsecutiveBreaks(div);
+    mergeConsecutiveBreaks(div);
+    return div.innerHTML;
+};
+const convertCommentsToSpans = (root) => {
+    const iterator = document.createNodeIterator(root, NodeFilter.SHOW_COMMENT, null);
+    let currentNode;
+    const comments = [];
+    while ((currentNode = iterator.nextNode())) {
+        comments.push(currentNode);
+    }
+    comments.forEach(comment => {
+        var _a;
+        const span = document.createElement(HTML_ELEMENTS.SPAN);
+        span.setAttribute('data-type', 'comment');
+        span.setAttribute('data-content', comment.textContent || '');
+        (_a = comment.parentNode) === null || _a === void 0 ? void 0 : _a.replaceChild(span, comment);
+    });
+};
+const cleanScriptsAndStyles = (root) => {
+    const scripts = root.querySelectorAll(`${HTML_ELEMENTS.SCRIPT}, ${HTML_ELEMENTS.STYLE}`);
+    scripts.forEach(el => {
+        const content = el.textContent;
+        if (content && content.trim()) {
+            el.textContent = dedent(content);
+        }
+    });
+};
+const unwrapHrFromParagraphs = (root) => {
+    const hrs = root.querySelectorAll(HTML_ELEMENTS.HR);
+    hrs.forEach(hr => {
+        var _a;
+        const parent = hr.parentElement;
+        if (parent && parent.tagName.toLowerCase() === HTML_ELEMENTS.P) {
+            // If HR is the only child (or only meaningful child), replace the p with hr
+            const siblings = Array.from(parent.childNodes).filter(node => {
+                var _a;
+                return node !== hr &&
+                    !(node.nodeType === Node.TEXT_NODE && !((_a = node.textContent) === null || _a === void 0 ? void 0 : _a.trim()));
+            });
+            if (siblings.length === 0) {
+                (_a = parent.parentNode) === null || _a === void 0 ? void 0 : _a.replaceChild(hr, parent);
+            }
+        }
+    });
+};
+const flattenEmptyParagraphs = (root) => {
+    // Remove empty paragraphs that only contain <br>
+    const paragraphs = root.querySelectorAll(HTML_ELEMENTS.P);
+    paragraphs.forEach(p => {
+        var _a;
+        const hasOnlyBrOrWhitespace = Array.from(p.childNodes).every(child => {
+            var _a;
+            return (child.nodeType === Node.ELEMENT_NODE &&
+                child.tagName.toLowerCase() === HTML_ELEMENTS.BR) ||
+                (child.nodeType === Node.TEXT_NODE && !((_a = child.textContent) === null || _a === void 0 ? void 0 : _a.trim()));
+        });
+        if (hasOnlyBrOrWhitespace && p.childNodes.length > 0) {
+            // Replace <p><br></p> with just <br>
+            const br = document.createElement(HTML_ELEMENTS.BR);
+            (_a = p.parentNode) === null || _a === void 0 ? void 0 : _a.replaceChild(br, p);
+        }
+    });
+};
+const mergeConsecutiveBreaks = (root) => {
+    const brs = root.querySelectorAll(HTML_ELEMENTS.BR);
+    brs.forEach(br => {
+        var _a, _b;
+        let next = br.nextSibling;
+        // Skip whitespace nodes
+        while (next &&
+            next.nodeType === Node.TEXT_NODE &&
+            !((_a = next.textContent) === null || _a === void 0 ? void 0 : _a.trim())) {
+            next = next.nextSibling;
+        }
+        // If next is also a br, remove this one
+        if (next &&
+            next.nodeType === Node.ELEMENT_NODE &&
+            next.tagName.toLowerCase() === HTML_ELEMENTS.BR) {
+            (_b = br.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(br);
+        }
+    });
+};
+const dedent = (str) => {
+    const lines = str.split('\n');
+    const nonEmptyLines = lines.filter(line => line.trim());
+    const LEADING_WHITESPACE_REGEX = /^\s*/;
+    const minIndent = nonEmptyLines.reduce((min, line) => {
+        const indent = line.match(LEADING_WHITESPACE_REGEX)[0].length;
+        return Math.min(min, indent);
+    }, Infinity);
+    return lines
+        .map(line => (line.length >= minIndent ? line.slice(minIndent) : line))
+        .join('\n')
+        .trim();
+};

package/dist/cjs/tiptap/utils/tiptap-extensions.d.ts

@@ -0,0 +1,21 @@
+import type { AnyExtension, Editor } from '@tiptap/core';
+export declare const getExtensions: (placeholder?: string) => AnyExtension[];
+/**
+ * Handles image file insertion logic for Drop and Paste events.
+ */
+export declare const handleImageFile: (editor: Editor, file: File, pos?: number) => void;
+/**
+ * Validates if the URI is allowed based on security rules.
+ */
+export declare const validateLink: (url: string, ctx: {
+    defaultProtocol: string;
+    protocols: (string | {
+        scheme: string;
+    })[];
+    defaultValidate: (href: string) => boolean;
+}) => boolean;
+/**
+ * Validates if the URL should be auto-linked.
+ */
+export declare const validateAutoLink: (url: string) => boolean;
+//# sourceMappingURL=tiptap-extensions.d.ts.map

package/dist/cjs/tiptap/utils/tiptap-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiptap-extensions.d.ts","sourceRoot":"","sources":["../../../../src/tiptap/utils/tiptap-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAwDzD,eAAO,MAAM,aAAa,GAAI,cAAc,MAAM,KAAG,YAAY,EAgGhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,EAAE,MAAM,IAAI,EAAE,MAAM,MAAM,SAqBvE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EACX,KAAK;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,CAAC,MAAM,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;IAC3C,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,YAmCF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,YAW3C,CAAC"}

package/dist/cjs/tiptap/utils/tiptap-extensions.js

@@ -0,0 +1,198 @@
+import Blockquote from '@tiptap/extension-blockquote';
+import Bold from '@tiptap/extension-bold';
+import Code from '@tiptap/extension-code';
+import CodeBlock from '@tiptap/extension-code-block';
+import Document from '@tiptap/extension-document';
+import FileHandler from '@tiptap/extension-file-handler';
+import HardBreak from '@tiptap/extension-hard-break';
+import Heading from '@tiptap/extension-heading';
+import Highlight from '@tiptap/extension-highlight';
+import History from '@tiptap/extension-history';
+import HorizontalRule from '@tiptap/extension-horizontal-rule';
+import Image from '@tiptap/extension-image';
+import Italic from '@tiptap/extension-italic';
+import Link from '@tiptap/extension-link';
+import { BulletList, ListItem, OrderedList, TaskItem, TaskList } from '@tiptap/extension-list';
+import Paragraph from '@tiptap/extension-paragraph';
+import Placeholder from '@tiptap/extension-placeholder';
+import Strike from '@tiptap/extension-strike';
+import { Table, TableRow } from '@tiptap/extension-table';
+import Text from '@tiptap/extension-text';
+import TextAlign from '@tiptap/extension-text-align';
+import { TextStyleKit } from '@tiptap/extension-text-style';
+import Typography from '@tiptap/extension-typography';
+import Underline from '@tiptap/extension-underline';
+import Youtube from '@tiptap/extension-youtube';
+import { Dropcursor, Gapcursor } from '@tiptap/extensions';
+import { ALLOWED_IMAGE_MIMES, EXTENSION_PRIORITIES, HEADING_LEVELS, LINK_CONFIG, TEXT_ALIGN_TYPES } from '../constants/editor-config';
+import { HTML_ELEMENTS } from '../constants/html-elements';
+import { CommentExtension, CustomTableCell, CustomTableHeader, HtmlBlockExtension, HtmlInlineExtension, IframeExtension, ImageUploadExtension, ResetMarksOnEnter } from '../extensions';
+import { SecureScriptExtension } from '../extensions/secure-script-extension';
+const DROP_CURSOR_COLOR = '#fff';
+export const getExtensions = (placeholder) => [
+    Document.extend({
+        content: '(block|horizontalRule)+'
+    }),
+    Text,
+    Paragraph.extend({
+        addAttributes() {
+            return {
+                style: { default: null },
+                class: { default: null },
+                id: { default: null }
+            };
+        }
+    }),
+    HardBreak,
+    HorizontalRule.extend({
+        parseHTML() {
+            return [
+                {
+                    tag: HTML_ELEMENTS.HR,
+                    priority: EXTENSION_PRIORITIES.HORIZONTAL_RULE
+                }
+            ];
+        },
+        addNodeView() {
+            return () => {
+                const hr = document.createElement(HTML_ELEMENTS.HR);
+                return { dom: hr };
+            };
+        }
+    }),
+    Heading.configure({
+        levels: [...HEADING_LEVELS]
+    }),
+    Blockquote,
+    CodeBlock,
+    HtmlBlockExtension,
+    HtmlInlineExtension,
+    IframeExtension,
+    SecureScriptExtension,
+    CommentExtension,
+    TextStyleKit,
+    Bold,
+    Italic,
+    Underline,
+    Strike,
+    Code,
+    Highlight.configure({ multicolor: true }),
+    Typography,
+    TextAlign.configure({
+        types: [...TEXT_ALIGN_TYPES]
+    }),
+    BulletList,
+    OrderedList,
+    ListItem,
+    TaskList,
+    TaskItem.configure({
+        nested: true
+    }),
+    Image,
+    ImageUploadExtension,
+    FileHandler.configure({
+        allowedMimeTypes: ALLOWED_IMAGE_MIMES,
+        onDrop: (currentEditor, files, pos) => {
+            files.forEach(file => handleImageFile(currentEditor, file, pos));
+        },
+        onPaste: (currentEditor, files, htmlContent) => {
+            if (htmlContent)
+                return false;
+            files.forEach(file => handleImageFile(currentEditor, file));
+        }
+    }),
+    Table.configure({ resizable: true }),
+    TableRow,
+    CustomTableHeader,
+    CustomTableCell,
+    Link.configure({
+        openOnClick: false,
+        autolink: true,
+        defaultProtocol: LINK_CONFIG.DEFAULT_PROTOCOL,
+        protocols: [...LINK_CONFIG.PROTOCOLS],
+        isAllowedUri: validateLink,
+        shouldAutoLink: validateAutoLink
+    }),
+    Gapcursor,
+    Dropcursor.configure({ color: DROP_CURSOR_COLOR }),
+    History,
+    ResetMarksOnEnter,
+    Youtube.configure({
+        controls: false,
+        nocookie: true,
+        allowFullscreen: false
+    }),
+    Placeholder.configure({
+        placeholder: placeholder || '',
+        emptyNodeClass: 'is-editor-empty'
+    })
+];
+/**
+ * Handles image file insertion logic for Drop and Paste events.
+ */
+export const handleImageFile = (editor, file, pos) => {
+    const fileReader = new FileReader();
+    fileReader.readAsDataURL(file);
+    fileReader.onload = () => {
+        const chain = editor.chain();
+        if (pos !== undefined) {
+            chain.insertContentAt(pos, {
+                type: 'image',
+                attrs: { src: fileReader.result }
+            });
+        }
+        else {
+            chain.insertContentAt(editor.state.selection.anchor, {
+                type: 'image',
+                attrs: { src: fileReader.result }
+            });
+        }
+        chain.focus().run();
+    };
+};
+/**
+ * Validates if the URI is allowed based on security rules.
+ */
+export const validateLink = (url, ctx) => {
+    if (!url)
+        return true;
+    try {
+        const parsedUrl = url.includes(':')
+            ? new URL(url)
+            : new URL(`${ctx.defaultProtocol}://${url}`);
+        if (!ctx.defaultValidate(parsedUrl.href)) {
+            return false;
+        }
+        const protocol = parsedUrl.protocol.replace(':', '');
+        if (LINK_CONFIG.DISALLOWED_PROTOCOLS.includes(protocol)) {
+            return false;
+        }
+        const allowedProtocols = ctx.protocols.map(p => typeof p === 'string' ? p : p.scheme);
+        if (!allowedProtocols.includes(protocol)) {
+            return false;
+        }
+        const domain = parsedUrl.hostname;
+        if (LINK_CONFIG.PHISHING_DOMAINS.includes(domain)) {
+            return false;
+        }
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+/**
+ * Validates if the URL should be auto-linked.
+ */
+export const validateAutoLink = (url) => {
+    try {
+        const parsedUrl = url.includes(':')
+            ? new URL(url)
+            : new URL(`${LINK_CONFIG.DEFAULT_PROTOCOL}://${url}`);
+        const domain = parsedUrl.hostname;
+        return !LINK_CONFIG.NO_AUTOLINK_DOMAINS.includes(domain);
+    }
+    catch (_a) {
+        return false;
+    }
+};

package/dist/esm/__tests__/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/esm/__tests__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/index.test.tsx"],"names":[],"mappings":""}

package/dist/esm/__tests__/index.test.js

@@ -0,0 +1,38 @@
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { AkiTextEditor } from '../index';
+vi.mock('../tiptap/components/tiptap', () => ({
+    Tiptap: (props) => (React.createElement("div", { "data-testid": "mock-tiptap" }, JSON.stringify(props)))
+}));
+describe('AkiTextEditor', () => {
+    it('should render Tiptap component and apply default class', () => {
+        render(React.createElement(AkiTextEditor, { value: "test content" }));
+        const wrapper = screen.getByTestId('mock-tiptap').parentElement;
+        expect(wrapper).toHaveClass('akinon-text-editor');
+        expect(screen.getByTestId('mock-tiptap')).toBeInTheDocument();
+    });
+    it('should apply custom wrapper class from classNames prop', () => {
+        const classNames = {
+            editorWrapper: 'custom-wrapper-class'
+        };
+        render(React.createElement(AkiTextEditor, { classNames: classNames }));
+        const wrapper = screen.getByTestId('mock-tiptap').parentElement;
+        expect(wrapper).toHaveClass('akinon-text-editor');
+        expect(wrapper).toHaveClass('custom-wrapper-class');
+    });
+    it('should pass all props to Tiptap component', () => {
+        const props = {
+            value: '<p>Hello</p>',
+            readOnly: true,
+            locale: 'tr',
+            onChange: vi.fn()
+        };
+        render(React.createElement(AkiTextEditor, Object.assign({}, props)));
+        const tiptap = screen.getByTestId('mock-tiptap');
+        const passedProps = JSON.parse(tiptap.textContent || '{}');
+        expect(passedProps.value).toBe(props.value);
+        expect(passedProps.readOnly).toBe(props.readOnly);
+        expect(passedProps.locale).toBe(props.locale);
+    });
+});

package/dist/esm/__tests__/index.test.tsx

@@ -0,0 +1,51 @@
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { AkiTextEditor } from '../index';
+import { TextEditorProps } from '../tiptap/types';
+
+vi.mock('../tiptap/components/tiptap', () => ({
+  Tiptap: (props: TextEditorProps) => (
+    <div data-testid="mock-tiptap">{JSON.stringify(props)}</div>
+  )
+}));
+
+describe('AkiTextEditor', () => {
+  it('should render Tiptap component and apply default class', () => {
+    render(<AkiTextEditor value="test content" />);
+
+    const wrapper = screen.getByTestId('mock-tiptap').parentElement;
+    expect(wrapper).toHaveClass('akinon-text-editor');
+    expect(screen.getByTestId('mock-tiptap')).toBeInTheDocument();
+  });
+
+  it('should apply custom wrapper class from classNames prop', () => {
+    const classNames = {
+      editorWrapper: 'custom-wrapper-class'
+    };
+    render(<AkiTextEditor classNames={classNames} />);
+
+    const wrapper = screen.getByTestId('mock-tiptap').parentElement;
+    expect(wrapper).toHaveClass('akinon-text-editor');
+    expect(wrapper).toHaveClass('custom-wrapper-class');
+  });
+
+  it('should pass all props to Tiptap component', () => {
+    const props = {
+      value: '<p>Hello</p>',
+      readOnly: true,
+      locale: 'tr' as const,
+      onChange: vi.fn()
+    };
+
+    render(<AkiTextEditor {...props} />);
+
+    const tiptap = screen.getByTestId('mock-tiptap');
+    const passedProps = JSON.parse(tiptap.textContent || '{}');
+
+    expect(passedProps.value).toBe(props.value);
+    expect(passedProps.readOnly).toBe(props.readOnly);
+    expect(passedProps.locale).toBe(props.locale);
+  });
+});

package/dist/esm/i18n/index.d.ts

@@ -0,0 +1,3 @@
+import { type AkilocaleInstance } from '@akinon/akilocale';
+export declare const i18n: AkilocaleInstance;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAKtE,eAAO,MAAM,IAAI,EAAE,iBAOjB,CAAC"}

package/dist/esm/i18n/index.js

@@ -0,0 +1,11 @@
+import { Akilocale } from '@akinon/akilocale';
+import en from './translations/en';
+import tr from './translations/tr';
+export const i18n = Akilocale.createInstance({
+    debug: false,
+    fallbackLng: 'en',
+    translations: {
+        en,
+        tr
+    }
+});

package/dist/esm/i18n/translations/en.d.ts

@@ -0,0 +1,86 @@
+declare const translations: {
+    readonly editor: {
+        readonly common: {
+            readonly save: "Save";
+            readonly remove: "Remove";
+            readonly cancel: "Cancel";
+            readonly apply: "Apply";
+        };
+        readonly heading: {
+            readonly tooltip: "Heading";
+            readonly paragraph: "Paragraph";
+            readonly h1: "Heading 1";
+            readonly h2: "Heading 2";
+            readonly h3: "Heading 3";
+            readonly h4: "Heading 4";
+        };
+        readonly toolbar: {
+            readonly bold: "Bold";
+            readonly italic: "Italic";
+            readonly strike: "Strike";
+            readonly underline: "Underline";
+            readonly clear_formatting: "Clear Formatting";
+            readonly text_color: "Text Color";
+            readonly highlight_color: "Highlight Color";
+            readonly bullet_list: "Bullet List";
+            readonly ordered_list: "Ordered List";
+            readonly code: "Code";
+            readonly code_block: "Code Block";
+            readonly blockquote: "Blockquote";
+            readonly horizontal_rule: "Horizontal Rule";
+            readonly insert_image: "Insert Image";
+            readonly undo: "Undo";
+            readonly redo: "Redo";
+            readonly source_mode: "Switch to Source Mode";
+            readonly normal_mode: "Switch to Preview Mode";
+            readonly link: "Link";
+            readonly align_left: "Align Left";
+            readonly align_center: "Align Center";
+            readonly align_right: "Align Right";
+            readonly justify: "Justify";
+        };
+        readonly link: {
+            readonly tooltip: "Add Link";
+            readonly text_placeholder: "Link text";
+            readonly url_placeholder: "https://your-link.com";
+        };
+        readonly youtube: {
+            readonly tooltip: "Insert YouTube Video";
+            readonly placeholder: "Enter YouTube URL";
+            readonly cancel: "Cancel";
+            readonly insert: "Insert";
+        };
+        readonly color_picker: {
+            readonly recommended: "Recommended";
+        };
+        readonly table: {
+            readonly insert_table: "Insert Table";
+            readonly select_size: "Select table size";
+            readonly cell_properties: "Cell Properties";
+            readonly add_column_before: "Add Column Before";
+            readonly add_column_after: "Add Column After";
+            readonly delete_column: "Delete Column";
+            readonly add_row_before: "Add Row Before";
+            readonly add_row_after: "Add Row After";
+            readonly delete_row: "Delete Row";
+            readonly merge_cells: "Merge Cells";
+            readonly split_cell: "Split Cell";
+            readonly delete_table: "Delete Table";
+            readonly border: "Border";
+            readonly background: "Background";
+            readonly width: "Width";
+            readonly border_style: {
+                readonly solid: "Solid";
+                readonly dashed: "Dashed";
+                readonly dotted: "Dotted";
+                readonly double: "Double";
+            };
+        };
+        readonly image_upload: {
+            readonly click_to_upload: "Click to upload or drag and drop";
+            readonly drag_and_drop_hint: "Maximum 3 files, 5MB each.";
+        };
+    };
+};
+export default translations;
+//# sourceMappingURL=en.d.ts.map

package/dist/esm/i18n/translations/en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../src/i18n/translations/en.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFR,CAAC;AAEX,eAAe,YAAY,CAAC"}