@adecore/editor 0.0.1 → 0.17.0-beta.1

package/dist/types.d.ts

@@ -0,0 +1,342 @@
+import type { Keymap } from './keymap-table.ts';
+import type { EditorCommand, FoldRole } from '@adecore/editor-core';
+export type { EditorCommand, FoldRole };
+export type EditorFoldOutline = 'off' | 'hover' | 'always';
+export type EditorViewCommand = 'collapseRegion' | 'expandRegion' | 'collapseAllRegions' | 'expandAllRegions' | 'collapseRegionRecursively' | 'expandRegionRecursively' | 'foldSelection' | 'collapseDocComments' | 'expandDocComments' | 'expandAllToLevel1' | 'expandAllToLevel2' | 'expandAllToLevel3' | 'expandAllToLevel4' | 'expandAllToLevel5' | 'toggleColumnMode';
+export type EditorRunCommand = EditorCommand | EditorViewCommand;
+export interface EditorFoldRange {
+    readonly startLine: number;
+    readonly endLine: number;
+}
+export interface EditorFolds {
+    readonly collapsed: readonly EditorFoldRange[];
+    readonly custom: readonly EditorFoldRange[];
+}
+export type EditorTheme = string;
+export interface EditorOptions {
+    readonly text: string;
+    readonly language?: string;
+    readonly path?: string;
+    readonly theme: EditorTheme;
+    readonly readOnly?: boolean;
+    readonly readOnlyReason?: string;
+    readonly wrap?: boolean;
+    readonly indentation?: EditorIndentation;
+    readonly smartKeys?: Partial<EditorSmartKeys>;
+    readonly guides?: boolean;
+    readonly whitespace?: boolean;
+    readonly rightMargin?: number | null;
+    readonly foldOutline?: EditorFoldOutline;
+    readonly messages?: Partial<EditorMessages>;
+    readonly folds?: EditorFolds;
+    readonly foldDefaults?: readonly FoldRole[];
+    readonly line?: number;
+    readonly column?: number;
+    readonly scrollTop?: number;
+}
+export interface EditorMessages {
+    readonly noMoreOccurrences: string;
+}
+export interface EditorSmartKeys {
+    readonly autoPairBrackets: boolean;
+    readonly autoPairQuotes: boolean;
+    readonly surroundSelection: boolean;
+    readonly tabOutOfClosers: boolean;
+    readonly smartIndentOnEnter: boolean;
+    readonly indentOnPaste: boolean;
+    readonly smartSemicolon: boolean;
+    readonly camelHumps: boolean;
+}
+export interface EditorFoldSymbol {
+    readonly range: EditorRange;
+    readonly body: 'function' | 'method' | 'class' | 'value';
+}
+export interface EditorFoldHints {
+    readonly symbols?: readonly EditorFoldSymbol[];
+    readonly ranges?: readonly (EditorFoldRange & {
+        readonly kind?: string;
+    })[];
+}
+export interface EditorBlock {
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly name?: string;
+    readonly kind?: string;
+}
+export type EditorChangeKind = 'added' | 'modified' | 'deleted';
+export interface EditorChangeMark {
+    readonly kind: EditorChangeKind;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+export type EditorMarkColor = string;
+export interface EditorAttributionMark {
+    readonly id: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly color: EditorMarkColor;
+}
+export interface EditorRemoteCursor {
+    readonly id: string;
+    readonly position: EditorPosition;
+    readonly name: string;
+    readonly color: EditorMarkColor;
+}
+export interface EditorLineHighlight {
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly color: EditorMarkColor;
+    readonly fill?: EditorMarkColor;
+    readonly sign?: string;
+}
+export interface EditorCodeBlockOptions {
+    readonly firstLine?: number;
+    readonly sign?: string;
+    readonly color?: EditorMarkColor;
+    readonly emphasis?: ReadonlyArray<ReadonlyArray<readonly [number, number]>>;
+    readonly faded?: boolean;
+}
+export interface EditorAttributionHover {
+    readonly id: string;
+    readonly rect: EditorRect;
+}
+export interface EditorPosition {
+    readonly line: number;
+    readonly character: number;
+}
+export interface EditorRange {
+    readonly start: EditorPosition;
+    readonly end: EditorPosition;
+}
+export interface EditorContentChange {
+    readonly range: EditorRange;
+    readonly text: string;
+}
+export interface EditorTextChange {
+    readonly changes: readonly EditorContentChange[];
+    readonly source: 'input' | 'command' | 'external';
+}
+export type EditorMarkerSeverity = 'error' | 'warning' | 'info' | 'hint';
+export interface EditorMarker {
+    readonly range: EditorRange;
+    readonly severity: EditorMarkerSeverity;
+    readonly unnecessary?: boolean;
+    readonly deprecated?: boolean;
+    readonly message?: string;
+}
+export type EditorHighlightKind = 'text' | 'read' | 'write';
+export interface EditorHighlight {
+    readonly range: EditorRange;
+    readonly kind: EditorHighlightKind;
+}
+export interface EditorRect {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+}
+export interface EditorHover {
+    readonly position: EditorPosition;
+    readonly rect: EditorRect;
+}
+export interface EditorClick {
+    readonly position: EditorPosition;
+    readonly mod: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+}
+export type EditorClickHandler = (click: EditorClick) => boolean;
+export interface EditorContextMenu {
+    readonly position: EditorPosition;
+    readonly inSelection: boolean;
+    readonly x: number;
+    readonly y: number;
+}
+export interface EditorWidget {
+    readonly id: string;
+    readonly line: number;
+    readonly placement?: 'above' | 'below';
+    readonly height?: number;
+    render(container: HTMLElement): void;
+}
+export interface EditorLineAction {
+    readonly id: string;
+    readonly line: number;
+    render(container: HTMLElement): void;
+}
+export interface EditorCodeVisionEntry {
+    readonly id: string;
+    readonly text: string;
+    readonly icon?: 'user' | 'users';
+    activate(anchor: EditorRect): void;
+}
+export interface EditorCodeVision {
+    readonly id: string;
+    readonly line: number;
+    readonly entries: readonly EditorCodeVisionEntry[];
+}
+export type EditorKeyHandler = (event: KeyboardEvent) => boolean;
+export type EditorSelectionRanges = (positions: readonly EditorPosition[]) => Promise<readonly (readonly EditorRange[])[] | null>;
+export interface EditorSemanticToken {
+    readonly line: number;
+    readonly character: number;
+    readonly length: number;
+    readonly scopes: readonly string[];
+}
+export interface ScopeStyle {
+    readonly color: string;
+    readonly fontStyle: number;
+}
+export type ScopeColors = (scopes: readonly string[]) => ScopeStyle | undefined;
+export type ScopeColorSource = (theme: EditorTheme) => Promise<ScopeColors | null>;
+export interface EditorInlayHint {
+    readonly position: EditorPosition;
+    readonly label: string;
+}
+export interface EditorGhostText {
+    readonly position: EditorPosition;
+    readonly text: string;
+    readonly accessory?: (container: HTMLElement) => void;
+}
+export interface EditorGutterAction {
+    readonly line: number;
+    readonly label: string;
+}
+export interface EditorGutterMarker {
+    readonly id: string;
+    readonly line: number;
+    readonly label: string;
+}
+export type EditorReveal = 'relative' | 'center' | 'centerDown' | 'centerUp';
+export interface EditorIndentation {
+    readonly tabSize: number;
+    readonly insertSpaces: boolean;
+}
+export interface EditorFindQuery {
+    readonly text: string;
+    readonly caseSensitive: boolean;
+    readonly wholeWord: boolean;
+    readonly regex: boolean;
+    readonly inSelection?: boolean;
+}
+export interface EditorFindState {
+    readonly count: number;
+    readonly current: number | null;
+    readonly noSelection?: boolean;
+}
+export interface EditorReplaceOptions {
+    readonly preserveCase?: boolean;
+}
+export interface EditorTrackedRange {
+    get(): EditorRange | null;
+    dispose(): void;
+}
+export interface Editor {
+    getText(): string;
+    setText(text: string): void;
+    onChange(listener: () => void): () => void;
+    onTextChange(listener: (change: EditorTextChange) => void): () => void;
+    positionAt(offset: number): EditorPosition;
+    offsetAt(position: EditorPosition): number;
+    textInRange(range: EditorRange): string;
+    onSave(listener: () => void): () => void;
+    onBlur(listener: () => void): () => void;
+    revealLine(line: number, reveal?: EditorReveal): void;
+    find(query: EditorFindQuery | null): void;
+    findStep(direction: 1 | -1): void;
+    replace(replacement: string, options?: EditorReplaceOptions): boolean;
+    replaceAll(replacement: string, options?: EditorReplaceOptions): number;
+    setReplacePreview(replacement: string | null, options?: EditorReplaceOptions): void;
+    selectFindMatches(): number;
+    findFromCursor(query: EditorFindQuery, direction: 1 | -1): boolean;
+    onFind(listener: (state: EditorFindState) => void): () => void;
+    endFind(): void;
+    setWrap(wrap: boolean): void;
+    setIndentation(indentation: EditorIndentation): void;
+    setSmartKeys(keys: Partial<EditorSmartKeys>): void;
+    setGuides(guides: boolean): void;
+    setWhitespace(whitespace: boolean): void;
+    setRightMargin(column: number | null): void;
+    setFoldOutline(outline: EditorFoldOutline): void;
+    setFoldHints(hints: EditorFoldHints | null): void;
+    setChangeMarks(marks: readonly EditorChangeMark[]): void;
+    setBlocks(blocks: readonly EditorBlock[] | null): void;
+    onScope(listener: (scope: readonly EditorBlock[]) => void): () => void;
+    setAttributionMarks(marks: readonly EditorAttributionMark[]): void;
+    setRemoteCursors(cursors: readonly EditorRemoteCursor[]): void;
+    setLineHighlights(highlights: readonly EditorLineHighlight[]): void;
+    renderCode(container: HTMLElement, text: string, options?: EditorCodeBlockOptions): void;
+    onAttributionHover(listener: (hover: EditorAttributionHover | null) => void): () => void;
+    setMarkers(markers: readonly EditorMarker[]): void;
+    setHighlights(highlights: readonly EditorHighlight[]): void;
+    setLink(range: EditorRange | null): void;
+    setSemanticTokens(tokens: readonly EditorSemanticToken[] | null): void;
+    setInlayHints(hints: readonly EditorInlayHint[]): void;
+    setGhostText(ghost: EditorGhostText | null): void;
+    setGutterAction(action: EditorGutterAction | null): void;
+    onGutterAction(listener: (line: number) => void): () => void;
+    setGutterMarkers(markers: readonly EditorGutterMarker[], owner?: string): void;
+    onGutterMarker(listener: (id: string) => void): () => void;
+    getCaret(): EditorPosition;
+    getScrollTop(): number;
+    getFolds(): EditorFolds;
+    getSelection(): EditorRange;
+    getSelections(): EditorRange[];
+    getIndentation(): EditorIndentation;
+    setCaret(position: EditorPosition, reveal?: EditorReveal): void;
+    setSelection(range: EditorRange, reveal?: EditorReveal): void;
+    setSelections(ranges: readonly EditorRange[], reveal?: EditorReveal): void;
+    onCaret(listener: (position: EditorPosition) => void): () => void;
+    onHover(listener: (hover: EditorHover | null) => void): () => void;
+    rectAt(position: EditorPosition): EditorRect | null;
+    getVisibleRange(): EditorRange;
+    onViewChange(listener: () => void): () => void;
+    setWidgets(widgets: readonly EditorWidget[], owner?: string): void;
+    setLineActions(actions: readonly EditorLineAction[], owner?: string): void;
+    setCodeVision(rows: readonly EditorCodeVision[]): void;
+    onClick(handler: EditorClickHandler): () => void;
+    onContextMenu(listener: (menu: EditorContextMenu) => void): () => void;
+    onKeyDown(handler: EditorKeyHandler): () => void;
+    setSelectionRanges(provider: EditorSelectionRanges | null): void;
+    trackRange(range: EditorRange): EditorTrackedRange;
+    applyEdits(edits: readonly EditorContentChange[]): boolean;
+    setTheme(theme: EditorTheme): void;
+    refreshFont(): void;
+    setReadOnly(readOnly: boolean, reason?: string): void;
+    runCommand(command: EditorRunCommand): boolean;
+    focus(): void;
+    dispose(): void;
+}
+export interface EditorEngine {
+    mount(element: HTMLElement, options: EditorOptions): Editor;
+}
+export interface KeyChord {
+    readonly mod: boolean;
+    readonly ctrl: boolean;
+    readonly meta: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+    readonly key: string;
+}
+export interface LineToken {
+    readonly length: number;
+    readonly color: string;
+    readonly fontStyle: number;
+}
+export interface TokenizedLine {
+    readonly tokens: readonly LineToken[];
+    readonly state: unknown;
+}
+export interface LineTokenizer {
+    tokenizeLine(text: string, state: unknown): TokenizedLine;
+    sameState(a: unknown, b: unknown): boolean;
+    stale?(): boolean;
+}
+export type TokenizerSource = (language: string | undefined, theme: EditorTheme, text?: string) => Promise<LineTokenizer | null>;
+export interface SmartEditorEngineOptions {
+    readonly keymap?: Keymap;
+    readonly tokenizer: TokenizerSource;
+    readonly scopeColors?: ScopeColorSource;
+    readonly handBack?: readonly KeyChord[];
+    readonly apple?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};