@n8n/design-system 2.33.3 → 2.34.0

package/dist/components/N8nInput/Input.types.d.ts

@@ -0,0 +1,37 @@
+import { InputSize, InputType } from '../../types/input';
+export type { InputSize, InputType };
+export type InputAutocomplete = 'off' | 'on' | 'new-password' | 'current-password' | 'given-name' | 'family-name' | 'one-time-code' | 'email';
+export interface InputProps {
+    modelValue?: string | number | null;
+    type?: InputType;
+    size?: InputSize;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    rows?: number;
+    masked?: boolean;
+    maxlength?: number;
+    autosize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    autofocus?: boolean;
+    autocomplete?: InputAutocomplete;
+    name?: string;
+}
+export interface InputEmits {
+    'update:modelValue': [value: string];
+    input: [value: string];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    keydown: [event: KeyboardEvent];
+    mousedown: [event: MouseEvent];
+}
+export interface InputSlots {
+    prefix?: () => unknown;
+    suffix?: () => unknown;
+    prepend?: () => unknown;
+    append?: () => unknown;
+}

package/dist/components/N8nInput/Input.vue.d.ts

@@ -0,0 +1,57 @@
+import { InputProps, InputSlots, InputSize } from './Input.types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<InputSlots> & InputSlots;
+    refs: {
+        inputRef: HTMLTextAreaElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputProps, {
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+    select: () => void | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: string) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: string) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    mousedown: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<InputProps> & Readonly<{
+    onInput?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onMousedown?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    type: import('./Input.types').InputType;
+    name: string;
+    disabled: boolean;
+    required: boolean;
+    size: InputSize;
+    placeholder: string;
+    rows: number;
+    modelValue: string | number | null;
+    readonly: boolean;
+    clearable: boolean;
+    masked: boolean;
+    maxlength: number;
+    autosize: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    autofocus: boolean;
+    autocomplete: import('./Input.types').InputAutocomplete;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLTextAreaElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/N8nInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default as N8nInput, default } from './Input.vue';
+export type * from './Input.types';

package/dist/components/N8nInputLabel/InputLabel.vue.d.ts

@@ -0,0 +1,39 @@
+import { TextColor } from '../../types/text';
+declare const SIZE: readonly ["small", "medium", "large"];
+interface InputLabelProps {
+    compact?: boolean;
+    color?: TextColor;
+    label?: string;
+    tooltipText?: string;
+    inputName?: string;
+    required?: boolean;
+    bold?: boolean;
+    size?: (typeof SIZE)[number];
+    underline?: boolean;
+    showTooltip?: boolean;
+    showOptions?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        options?(_: {}): any;
+        issues?(_: {}): any;
+        persistentOptions?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputLabelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<InputLabelProps> & Readonly<{}>, {
+    bold: boolean;
+    size: (typeof SIZE)[number];
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/N8nInputLabel/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nInputLabel } from './InputLabel.vue';
+export default N8nInputLabel;

package/dist/components/N8nInputNumber/InputNumber.vue.d.ts

@@ -0,0 +1,16 @@
+import { InputSize } from '../../types';
+type InputNumberProps = {
+    size?: InputSize;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+};
+declare const _default: import('vue').DefineComponent<InputNumberProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<InputNumberProps> & Readonly<{}>, {
+    size: InputSize;
+    step: number;
+    min: number;
+    max: number;
+    precision: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/N8nInputNumber/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nInputNumber } from './InputNumber.vue';
+export default N8nInputNumber;

package/dist/components/N8nKeyboardShortcut/N8nKeyboardShortcut.vue.d.ts

@@ -0,0 +1,3 @@
+import { KeyboardShortcut } from '../../types/keyboardshortcut';
+declare const _default: import('vue').DefineComponent<KeyboardShortcut, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<KeyboardShortcut> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/N8nKeyboardShortcut/index.d.ts

@@ -0,0 +1 @@
+export { default as N8nKeyboardShortcut } from './N8nKeyboardShortcut.vue';

package/dist/components/N8nLink/Link.vue.d.ts

@@ -0,0 +1,35 @@
+import { RouteLocationRaw } from 'vue-router';
+import { TextSize } from '../../types/text';
+declare const THEME: readonly ["primary", "danger", "text", "secondary"];
+interface LinkProps {
+    to?: RouteLocationRaw | string;
+    size?: TextSize;
+    newWindow?: boolean;
+    bold?: boolean;
+    underline?: boolean;
+    theme?: (typeof THEME)[number];
+    title?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<LinkProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LinkProps> & Readonly<{}>, {
+    bold: boolean;
+    underline: boolean;
+    size: TextSize;
+    theme: (typeof THEME)[number];
+    to: RouteLocationRaw | string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/N8nLink/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nLink } from './Link.vue';
+export default N8nLink;

package/dist/components/N8nLoading/Loading.vue.d.ts

@@ -0,0 +1,18 @@
+declare const VARIANT: readonly ["custom", "p", "text", "h1", "h3", "text", "caption", "button", "image", "circle", "rect"];
+interface LoadingProps {
+    animated?: boolean;
+    loading?: boolean;
+    rows?: number;
+    cols?: number;
+    shrinkLast?: boolean;
+    variant?: (typeof VARIANT)[number];
+}
+declare const _default: import('vue').DefineComponent<LoadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LoadingProps> & Readonly<{}>, {
+    variant: (typeof VARIANT)[number];
+    loading: boolean;
+    rows: number;
+    animated: boolean;
+    cols: number;
+    shrinkLast: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/N8nLoading/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nLoading } from './Loading.vue';
+export default N8nLoading;

package/dist/components/N8nLogo/Logo.vue.d.ts

@@ -0,0 +1,39 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        logo: unknown;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<({
+    size: "large";
+} & {
+    releaseChannel?: "stable" | "beta" | "nightly" | "dev" | "rc";
+}) | ({
+    size: "small";
+    collapsed: boolean;
+} & {
+    releaseChannel?: "stable" | "beta" | "nightly" | "dev" | "rc";
+}), {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<({
+    size: "large";
+} & {
+    releaseChannel?: "stable" | "beta" | "nightly" | "dev" | "rc";
+}) | ({
+    size: "small";
+    collapsed: boolean;
+} & {
+    releaseChannel?: "stable" | "beta" | "nightly" | "dev" | "rc";
+})> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    logo: unknown;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/N8nLogo/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Logo } from './Logo.vue';
+export default Logo;

package/dist/components/N8nMarkdown/Markdown.vue.d.ts

@@ -0,0 +1,43 @@
+import { Options as MarkdownOptions } from 'markdown-it';
+import { default as markdownLink } from 'markdown-it-link-attributes';
+import { default as markdownTaskLists } from 'markdown-it-task-lists';
+import { YoutubeEmbedConfig } from './youtube';
+interface IImage {
+    id: string | number;
+    url: string;
+}
+interface Options {
+    markdown: MarkdownOptions;
+    linkAttributes: markdownLink.Config;
+    tasklists: markdownTaskLists.Config;
+    youtube: YoutubeEmbedConfig;
+}
+interface MarkdownProps {
+    content?: string | null;
+    withMultiBreaks?: boolean;
+    images?: IImage[];
+    loading?: boolean;
+    loadingBlocks?: number;
+    loadingRows?: number;
+    theme?: string;
+    options?: Options;
+}
+declare const _default: import('vue').DefineComponent<MarkdownProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "markdown-click": (link: HTMLAnchorElement, e: MouseEvent) => any;
+    "update-content": (content: string) => any;
+}, string, import('vue').PublicProps, Readonly<MarkdownProps> & Readonly<{
+    "onMarkdown-click"?: ((link: HTMLAnchorElement, e: MouseEvent) => any) | undefined;
+    "onUpdate-content"?: ((content: string) => any) | undefined;
+}>, {
+    content: string | null;
+    theme: string;
+    loading: boolean;
+    images: IImage[];
+    options: Options;
+    withMultiBreaks: boolean;
+    loadingBlocks: number;
+    loadingRows: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    editor: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/N8nMarkdown/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nMarkdown } from './Markdown.vue';
+export default N8nMarkdown;

package/dist/components/N8nMarkdown/youtube.d.ts

@@ -0,0 +1,9 @@
+import { default as MarkdownIt } from 'markdown-it';
+export declare const YOUTUBE_EMBED_SRC_REGEX: RegExp;
+export interface YoutubeEmbedConfig {
+    width?: number | string;
+    height?: number | string;
+    title?: string;
+    nocookie?: boolean;
+}
+export declare const markdownYoutubeEmbed: (md: MarkdownIt, options: YoutubeEmbedConfig) => void;

package/dist/components/N8nMarkdownEditor/MarkdownEditor.types.d.ts

@@ -0,0 +1,22 @@
+import { Editor, Extension, EditorOptions } from '@tiptap/core';
+export type MarkdownEditorVariant = 'ghost' | 'contained';
+export type MarkdownEditorToolbarMode = 'never' | 'hover' | 'always';
+export type N8nMarkdownEditorProps = {
+    modelValue: string;
+    variant?: MarkdownEditorVariant;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    showToolbar?: MarkdownEditorToolbarMode;
+    maxHeight?: string | number;
+    extensions?: Extension[];
+    editorProps?: EditorOptions['editorProps'];
+    containerClass?: string;
+};
+export type N8nMarkdownEditorEmits = {
+    'update:modelValue': [value: string];
+    input: [value: string];
+    focus: [event: FocusEvent];
+    blur: [value: string, event: FocusEvent];
+    ready: [editor: Editor];
+};

package/dist/components/N8nMarkdownEditor/MarkdownEditor.vue.d.ts

@@ -0,0 +1,37 @@
+import { Editor } from '@tiptap/core';
+import { N8nMarkdownEditorProps } from './MarkdownEditor.types';
+declare function focus(): void;
+declare function blur(): void;
+declare function getMarkdown(): string;
+declare function getEditor(): Editor | undefined;
+declare const _default: import('vue').DefineComponent<N8nMarkdownEditorProps, {
+    focus: typeof focus;
+    blur: typeof blur;
+    getMarkdown: typeof getMarkdown;
+    getEditor: typeof getEditor;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: string) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: string) => any;
+    blur: (value: string, event: FocusEvent) => any;
+    ready: (editor: Editor) => any;
+}, string, import('vue').PublicProps, Readonly<N8nMarkdownEditorProps> & Readonly<{
+    onInput?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onBlur?: ((value: string, event: FocusEvent) => any) | undefined;
+    onReady?: ((editor: Editor) => any) | undefined;
+}>, {
+    disabled: boolean;
+    variant: import('./MarkdownEditor.types').MarkdownEditorVariant;
+    placeholder: string;
+    modelValue: string;
+    readonly: boolean;
+    maxHeight: string | number;
+    containerClass: string;
+    showToolbar: import('./MarkdownEditor.types').MarkdownEditorToolbarMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    container: HTMLDivElement;
+    rawEditor: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/N8nMarkdownEditor/MarkdownEditorToolbar.vue.d.ts

@@ -0,0 +1,15 @@
+import { Editor } from '@tiptap/core';
+import { MarkdownEditorVariant, MarkdownEditorToolbarMode } from './MarkdownEditor.types';
+type __VLS_Props = {
+    editor: Editor;
+    disabled?: boolean;
+    isRawMode?: boolean;
+    mode: Exclude<MarkdownEditorToolbarMode, 'never'>;
+    variant: MarkdownEditorVariant;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:isRawMode": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:isRawMode"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/N8nMarkdownEditor/composables/useMarkdownEditor.d.ts

@@ -0,0 +1,3 @@
+import { SetupContext } from 'vue';
+import { N8nMarkdownEditorEmits, N8nMarkdownEditorProps } from '../MarkdownEditor.types';
+export declare const useMarkdownEditor: (props: Readonly<N8nMarkdownEditorProps>, emit: SetupContext<N8nMarkdownEditorEmits>["emit"]) => import('vue').ShallowRef<import('@tiptap/vue-3').Editor | undefined, import('@tiptap/vue-3').Editor | undefined>;

package/dist/components/N8nMarkdownEditor/index.d.ts

@@ -0,0 +1,3 @@
+import { default as N8nMarkdownEditor } from './MarkdownEditor.vue';
+export default N8nMarkdownEditor;
+export type * from './MarkdownEditor.types';

package/dist/components/N8nMarkdownEditor/markdownEditorUtils.d.ts

@@ -0,0 +1,7 @@
+import { Content, Editor } from '@tiptap/core';
+export declare const getEditorContent: (markdown: string) => Content;
+export declare const setEditorContent: (editor: Editor, markdown: string) => void;
+export declare const isUrl: (value: string) => boolean;
+export declare const isSelectionInsideNode: (editor: Editor, nodeName: string) => boolean;
+export declare const copyMarkdown: (editor: Editor, event: ClipboardEvent) => boolean;
+export declare const pasteMarkdown: (editor: Editor, event: ClipboardEvent) => boolean;

package/dist/components/N8nMenuItem/MenuItem.vue.d.ts

@@ -0,0 +1,16 @@
+import { IMenuItem } from '../../types';
+type __VLS_Props = {
+    item: IMenuItem;
+    active?: boolean;
+    empty?: boolean;
+    compact?: boolean;
+    level?: number;
+    open?: boolean;
+    ariaLabel?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/N8nMenuItem/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nMenuItem } from './MenuItem.vue';
+export default N8nMenuItem;

package/dist/components/N8nMenuItem/routerUtil.d.ts

@@ -0,0 +1,3 @@
+import { RouteLocationNormalizedLoaded } from 'vue-router';
+import { IMenuElement } from '../../types';
+export declare function doesMenuItemMatchCurrentRoute(item: IMenuElement, currentRoute: RouteLocationNormalizedLoaded): boolean;