@journeyapps-labs/reactor-mod-editor 1.0.0

package/README.md

@@ -0,0 +1,10 @@
+# Module editor
+
+Make sure to put this in any modules that will need monaco (in the custom webpack.config.js):
+
+```js
+webpack = patchImportedLibrary({
+  "w": webpack,
+  "module": 'monaco-editor'
+})
+```

package/dist/@types/EditorModule.d.ts

@@ -0,0 +1,7 @@
+import { AbstractReactorModule } from '@journeyapps-labs/reactor-mod';
+import { Container } from '@journeyapps-labs/lib-ioc';
+export declare class EditorModule extends AbstractReactorModule {
+    constructor();
+    register(ioc: Container): void;
+    init(ioc: Container): Promise<any>;
+}

package/dist/@types/MonacoCommandPalletSearchEngine.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { MonacoShortcut } from './shortcuts/MonacoShortcut';
+import { CMDPalletSearchEngine, CMDPalletSearchEngineResult, CommandPalletSearchResultEntry, MousePosition } from '@journeyapps-labs/reactor-mod';
+import * as monaco from 'monaco-editor';
+import { MonacoShortcutHandler } from './shortcuts/MonacoShortcutHandler';
+import { MonacoKeybindingStore } from './stores/keybindings/MonacoKeybindingStore';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface CMDPalletMonacoActionSearchEntry extends CommandPalletSearchResultEntry {
+    action: monaco.editor.IEditorAction;
+}
+export interface MonacoCommandPalletSearchEngineOptions {
+    keybindingStore: MonacoKeybindingStore;
+    handler: MonacoShortcutHandler;
+}
+export declare class MonacoCommandPalletSearchEngine extends CMDPalletSearchEngine<CMDPalletMonacoActionSearchEntry> {
+    protected options2: MonacoCommandPalletSearchEngineOptions;
+    constructor(options2: MonacoCommandPalletSearchEngineOptions);
+    getShortcuts(action: MonacoShortcut): React.JSX.Element;
+    doSearch(event: SearchEvent): CMDPalletSearchEngineResult<CMDPalletMonacoActionSearchEntry>;
+    handleSelection(entry: CMDPalletMonacoActionSearchEntry, event: MousePosition): Promise<boolean>;
+}

package/dist/@types/actions/ChangeEditorThemeAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent } from '@journeyapps-labs/reactor-mod';
+import { EditorTheme, MonacoThemeStore } from '../stores/MonacoThemeStore';
+export declare class ChangeEditorThemeAction extends EntityAction<EditorTheme> {
+    static NAME: string;
+    accessor reactorThemeStore: MonacoThemeStore;
+    constructor();
+    protected fireEvent(event: EntityActionEvent<EditorTheme>): Promise<any>;
+    static get(): ChangeEditorThemeAction;
+}

package/dist/@types/index.d.ts

@@ -0,0 +1,16 @@
+import { EditorModule } from './EditorModule';
+export * from './languages/logs';
+export * from './languages/languages';
+export * from './widgets/EditorWidget';
+export * from './widgets/DualEditorWidget';
+export * from './widgets/SimpleEditorWidget';
+export * from './theme/theme-utils';
+export * from './shortcuts/MonacoShortcutHandler';
+export * from './shortcuts/MonacoShortcut';
+export * from './stores/MonacoStore';
+export * from './stores/MonacoThemeStore';
+export * from './EditorModule';
+export * from './theme-reactor/editor-theme-fragment';
+export * from './utils/paths';
+export * from './utils/useEditorStickyHeader';
+export default EditorModule;

package/dist/@types/languages/languages.d.ts

@@ -0,0 +1,39 @@
+import * as monaco from 'monaco-editor';
+export declare enum MonacoLanguages {
+    JSON = "json",
+    JAVASCRIPT = "javascript",
+    XML = "xml",
+    JXML = "jxml",
+    HTML = "html",
+    CSS = "css",
+    YAML = "yaml",
+    MARKDOWN = "markdown",
+    SQL = "sql",
+    TS = "typescript",
+    HANDLEBARS = "handlebars"
+}
+export declare enum MonacoLanguageScopes {
+    JAVASCRIPT = "source.js",
+    XML = "text.xml",
+    JXML = "text.jxml",
+    JSON = "source.json",
+    HTML = "text.html.basic",
+    CSS = "source.css",
+    YAML = "source.yaml",
+    MARKDOWN = "text.html.markdown",
+    SQL = "source.sql",
+    TS = "source.ts",
+    REGEX = "source.js.regexp",
+    HANDLEBARS = "handlebars.html"
+}
+export interface GrammerMappingEntry {
+    format: 'json' | 'plist';
+    url: string;
+    monaco?: MonacoLanguages;
+    language?: Partial<monaco.languages.ILanguageExtensionPoint>;
+    hook?: () => any;
+}
+export interface GrammerMappingType {
+    [key: string]: GrammerMappingEntry;
+}
+export declare const GrammerMapping: GrammerMappingType;

package/dist/@types/languages/logs.d.ts

@@ -0,0 +1,3 @@
+import * as monaco from 'monaco-editor';
+import ILanguage = monaco.languages.IMonarchLanguage;
+export declare const LOGS_LANGUAGE: ILanguage;

package/dist/@types/providers/EditorThemeProvider.d.ts

@@ -0,0 +1,14 @@
+import { SimpleProvider, SerializedEntity } from '@journeyapps-labs/reactor-mod';
+import { EditorTheme, MonacoThemeStore } from '../stores/MonacoThemeStore';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface SerializedEditorTheme extends SerializedEntity {
+    themeID: string;
+}
+export declare class EditorThemeProvider extends SimpleProvider<EditorTheme, SerializedEditorTheme> {
+    static TYPE: string;
+    themeStore: MonacoThemeStore;
+    constructor(store: MonacoThemeStore);
+    serialize(entity: EditorTheme): SerializedEditorTheme;
+    deserialize(entity: SerializedEditorTheme): Promise<EditorTheme>;
+    getEntities(event: SearchEvent): Promise<EditorTheme[]>;
+}

package/dist/@types/settings/StoredThemesSettings.d.ts

@@ -0,0 +1,13 @@
+import { AbstractSetting } from '@journeyapps-labs/reactor-mod';
+import { IObservableArray } from 'mobx';
+import { EditorTheme } from '../stores/MonacoThemeStore';
+export declare class StoredThemesSettings extends AbstractSetting {
+    static KEY: string;
+    accessor themes: IObservableArray<EditorTheme>;
+    constructor();
+    reset(): void;
+    protected serialize(): {
+        items: IObservableArray<EditorTheme>;
+    };
+    protected deserialize(data: any): void;
+}

package/dist/@types/settings/VimSupportSetting.d.ts

@@ -0,0 +1,7 @@
+import { BooleanSetting } from '@journeyapps-labs/reactor-mod';
+export declare class EnableVimSetting extends BooleanSetting {
+    static KEY: string;
+    constructor();
+    static enabled(): boolean;
+    static get(): EnableVimSetting;
+}

package/dist/@types/shortcuts/MonacoShortcut.d.ts

@@ -0,0 +1,9 @@
+import { Shortcut, ShortcutChord } from '@journeyapps-labs/reactor-mod';
+import { MonacoShortcutHandler } from './MonacoShortcutHandler';
+import { MonacoStoreAction } from '../stores/keybindings/definitions';
+export declare class MonacoShortcut extends Shortcut<MonacoShortcutHandler> {
+    dispose(): void;
+    getMonacoStoreAction(): MonacoStoreAction;
+    getAsMonacoPrimitive(primary: boolean): any;
+    setChord(chord: ShortcutChord, fire?: boolean): void;
+}

package/dist/@types/shortcuts/MonacoShortcutHandler.d.ts

@@ -0,0 +1,17 @@
+import { ShortcutHandler, ShortcutHandlerAction, ShortcutHandlerSerialized, ShortcutKey } from '@journeyapps-labs/reactor-mod';
+import { MonacoShortcut } from './MonacoShortcut';
+import { MonacoKeybindingStore } from '../stores/keybindings/MonacoKeybindingStore';
+import { Keybinding } from '../stores/keybindings/definitions';
+export interface MonacoShortcutHandlerOptions {
+    keybindingStore: MonacoKeybindingStore;
+}
+export declare class MonacoShortcutHandler extends ShortcutHandler<MonacoShortcut> {
+    protected options2: MonacoShortcutHandlerOptions;
+    constructor(options2: MonacoShortcutHandlerOptions);
+    get store(): MonacoKeybindingStore;
+    deserialize(data: ShortcutHandlerSerialized): Promise<void>;
+    getMetaForAction(id: string): ShortcutHandlerAction<MonacoShortcutHandler>;
+    getPossibleActions(): ShortcutHandlerAction<MonacoShortcutHandler>[];
+    getShortcutKeys(item: Keybinding, primary: boolean): ShortcutKey[];
+    generateShortcut(data: ShortcutHandlerAction<MonacoShortcutHandler>): MonacoShortcut;
+}

package/dist/@types/shortcuts/MonacoShortcutMap.d.ts

@@ -0,0 +1,83 @@
+import * as monaco from 'monaco-editor';
+import * as _ from 'lodash';
+export declare const MonacoMap: {
+    Backspace: monaco.KeyCode;
+    Tab: monaco.KeyCode;
+    Enter: monaco.KeyCode;
+    Shift: monaco.KeyCode;
+    ' ': monaco.KeyCode;
+    ArrowUp: monaco.KeyCode;
+    ArrowLeft: monaco.KeyCode;
+    ArrowRight: monaco.KeyCode;
+    ArrowDown: monaco.KeyCode;
+    Delete: monaco.KeyCode;
+    Escape: monaco.KeyCode;
+    '[': monaco.KeyCode;
+    ']': monaco.KeyCode;
+    '0': monaco.KeyCode;
+    '1': monaco.KeyCode;
+    '2': monaco.KeyCode;
+    '3': monaco.KeyCode;
+    '4': monaco.KeyCode;
+    '5': monaco.KeyCode;
+    '6': monaco.KeyCode;
+    '7': monaco.KeyCode;
+    '8': monaco.KeyCode;
+    '9': monaco.KeyCode;
+    a: monaco.KeyCode;
+    b: monaco.KeyCode;
+    c: monaco.KeyCode;
+    d: monaco.KeyCode;
+    e: monaco.KeyCode;
+    f: monaco.KeyCode;
+    g: monaco.KeyCode;
+    h: monaco.KeyCode;
+    i: monaco.KeyCode;
+    j: monaco.KeyCode;
+    k: monaco.KeyCode;
+    l: monaco.KeyCode;
+    m: monaco.KeyCode;
+    n: monaco.KeyCode;
+    o: monaco.KeyCode;
+    p: monaco.KeyCode;
+    q: monaco.KeyCode;
+    r: monaco.KeyCode;
+    s: monaco.KeyCode;
+    t: monaco.KeyCode;
+    u: monaco.KeyCode;
+    v: monaco.KeyCode;
+    w: monaco.KeyCode;
+    x: monaco.KeyCode;
+    y: monaco.KeyCode;
+    z: monaco.KeyCode;
+    F1: monaco.KeyCode;
+    F2: monaco.KeyCode;
+    F3: monaco.KeyCode;
+    F4: monaco.KeyCode;
+    F5: monaco.KeyCode;
+    F6: monaco.KeyCode;
+    F7: monaco.KeyCode;
+    F8: monaco.KeyCode;
+    F9: monaco.KeyCode;
+    F10: monaco.KeyCode;
+    F11: monaco.KeyCode;
+    F12: monaco.KeyCode;
+    F13: monaco.KeyCode;
+    F14: monaco.KeyCode;
+    F15: monaco.KeyCode;
+    F16: monaco.KeyCode;
+    F17: monaco.KeyCode;
+    F18: monaco.KeyCode;
+    F19: monaco.KeyCode;
+    '.': monaco.KeyCode;
+    ',': monaco.KeyCode;
+    '\\': monaco.KeyCode;
+    '/': monaco.KeyCode;
+    PageUp: monaco.KeyCode;
+    PageDown: monaco.KeyCode;
+    Home: monaco.KeyCode;
+    End: monaco.KeyCode;
+    '-': monaco.KeyCode;
+    '=': monaco.KeyCode;
+};
+export declare const MonacoMapInverted: _.Dictionary<string>;

package/dist/@types/stores/MonacoStore.d.ts

@@ -0,0 +1,38 @@
+import * as monaco from 'monaco-editor';
+import { GrammerMappingEntry, GrammerMappingType, MonacoLanguages } from '../languages/languages';
+import { AbstractStore, AbstractStoreListener } from '@journeyapps-labs/reactor-mod';
+export interface MonacoEditorType extends monaco.editor.IStandaloneCodeEditor {
+    _standaloneKeybindingService: {
+        updateResolver(): any;
+    };
+    _actions: Map<string, {
+        id: string;
+        label: string;
+    }>;
+    _commandService: {
+        executeCommand(id: string, ...args: any[]): Promise<any>;
+    };
+}
+export interface MonacoStoreListener extends AbstractStoreListener {
+    gotEditor: (editor: MonacoEditorType) => any;
+}
+export declare class MonacoStore extends AbstractStore<void, MonacoStoreListener> {
+    editors: {
+        [id: string]: MonacoEditorType;
+    };
+    focusedEditor: MonacoEditorType;
+    languages: GrammerMappingType;
+    enabledLanguages: MonacoLanguages[];
+    constructor();
+    registerLanguage(key: string, language: GrammerMappingEntry): void;
+    enableLanguages(languages: MonacoLanguages[]): void;
+    getLanguage(languageID: MonacoLanguages): GrammerMappingEntry;
+    getLanguageScope(languageID: MonacoLanguages): string;
+    init(): Promise<boolean>;
+    createHeadlessEditorInstance(): Promise<{
+        editor: MonacoEditorType;
+        dispose: () => any;
+    }>;
+    registerEditor(editor: MonacoEditorType): void;
+    deregisterEditor(editor: monaco.editor.IEditor): void;
+}

package/dist/@types/stores/MonacoThemeStore.d.ts

@@ -0,0 +1,34 @@
+import { VSIXTheme } from '../theme/theme-utils';
+import { AbstractStore, ProviderControl, ProviderControlOptions } from '@journeyapps-labs/reactor-mod';
+import * as monaco from 'monaco-editor';
+import { StoredThemesSettings } from '../settings/StoredThemesSettings';
+export interface EditorTheme {
+    label: string;
+    theme: monaco.editor.IStandaloneThemeData;
+    key: string;
+    system: boolean;
+    compatibility: boolean;
+}
+export declare class EditorThemeControl extends ProviderControl<EditorTheme> {
+    store: MonacoThemeStore;
+    constructor(options: ProviderControlOptions<EditorTheme>, store: MonacoThemeStore);
+    reset(): Promise<void>;
+}
+export declare class MonacoThemeStore extends AbstractStore {
+    selectedTheme: ProviderControl<EditorTheme>;
+    storedThemes: StoredThemesSettings;
+    additionalThemes: Map<string, string>;
+    constructor();
+    clone(): EditorTheme;
+    patchTheme(editorTheme: EditorTheme): void;
+    deleteTheme(editorTheme: EditorTheme): void;
+    addTheme(theme: VSIXTheme): void;
+    getMonacoThemeForReactorTheme(theme: string): EditorTheme;
+    getSystemThemes(): {
+        [key: string]: EditorTheme;
+    };
+    getTheme(key: string): Promise<EditorTheme>;
+    getThemes(): {
+        [key: string]: EditorTheme;
+    };
+}

package/dist/@types/stores/keybindings/KeybindingsRegistry.d.ts

@@ -0,0 +1,46 @@
+import { ContextKey, Keybinding } from './definitions';
+import * as _ from 'lodash';
+import { BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+export interface ResolvedKeybindingItem {
+    command: string;
+    keybinding: Keybinding;
+    when: ContextKey;
+}
+export interface CommandBindingsListener {
+    updated: () => any;
+}
+export declare abstract class CommandBindings extends BaseObserver<CommandBindingsListener> {
+    protected custom: Keybinding[];
+    constructor();
+    updated(): void;
+    abstract serialize(): ResolvedKeybindingItem[];
+    abstract getDefaults(): Keybinding[];
+    addKeybinding(binding: Keybinding): void;
+    deleteKeybinding(binding: Keybinding): void;
+}
+export declare class CustomCommandBindings extends CommandBindings {
+    protected command: string;
+    constructor(command: string);
+    serialize(): ResolvedKeybindingItem[];
+    getDefaults(): Keybinding[];
+}
+export declare class ExistingCommandBindings extends CommandBindings {
+    protected command: string;
+    defaults: ResolvedKeybindingItem[];
+    touched: boolean;
+    constructor(command: string, defaults: ResolvedKeybindingItem[]);
+    addKeybinding(binding: Keybinding): void;
+    deleteKeybinding(binding: Keybinding): void;
+    serialize(): ResolvedKeybindingItem[];
+    getDefaults(): Keybinding[];
+}
+export interface KeybindingsRegistryListener {
+    saved: () => any;
+}
+export declare class KeybindingsRegistry extends BaseObserver<KeybindingsRegistryListener> {
+    map: Map<string, CommandBindings>;
+    constructor();
+    getCommandKeybinding(id: string): CommandBindings;
+    load(): void;
+    save: _.DebouncedFunc<() => void>;
+}

package/dist/@types/stores/keybindings/MonacoKeybindingStore.d.ts

@@ -0,0 +1,27 @@
+import * as _ from 'lodash';
+import { KeyCodeChord, MonacoStoreAction } from './definitions';
+import { MonacoEditorType, MonacoStore } from '../MonacoStore';
+import { AbstractStore, CMDPalletStore } from '@journeyapps-labs/reactor-mod';
+import { KeybindingsRegistry } from './KeybindingsRegistry';
+export interface PatchActionOperation {
+    action: MonacoStoreAction;
+    binding: KeyCodeChord;
+    binding2: KeyCodeChord;
+}
+export interface MonacoKeybindingStoreOptions {
+    editorStore: MonacoStore;
+    cmdPaletteStore: CMDPalletStore;
+}
+export declare class MonacoKeybindingStore extends AbstractStore {
+    protected options2: MonacoKeybindingStoreOptions;
+    actions: MonacoStoreAction[];
+    focusedEditor: MonacoEditorType;
+    keybindingRegistry: KeybindingsRegistry;
+    constructor(options2: MonacoKeybindingStoreOptions);
+    protected _init(): Promise<void>;
+    getActionFromID(id: string): MonacoStoreAction;
+    getContextualActions(): import("monaco-editor").editor.IEditorAction[];
+    unbindAction(actionID: string, bindings: KeyCodeChord[]): void;
+    updateAction(operation: PatchActionOperation): void;
+    getDefaultActions: (() => Promise<MonacoStoreAction[]>) & _.MemoizedFunction;
+}

package/dist/@types/stores/keybindings/definitions.d.ts

@@ -0,0 +1,21 @@
+export interface ContextKey {
+    key: string;
+    negated: null;
+    type: number;
+}
+export interface MonacoStoreAction {
+    id: string;
+    label: string;
+    bindings: Keybinding[];
+}
+export interface KeyCodeChord {
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    keyCode: number;
+    equals: (item: KeyCodeChord) => boolean;
+}
+export interface Keybinding {
+    chords: KeyCodeChord[];
+}

package/dist/@types/stores/keybindings/utils.d.ts

@@ -0,0 +1,2 @@
+import { Keybinding } from './definitions';
+export declare const compareChords: (a: Keybinding, b: Keybinding) => boolean;

package/dist/@types/theme/EditorThemePreferencesWidget.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { ComboBoxStore } from '@journeyapps-labs/reactor-mod';
+import * as _ from 'lodash';
+import { MonacoThemeStore, EditorTheme } from '../stores/MonacoThemeStore';
+export interface EditorThemePreferencesWidgetProps {
+    save: (theme: EditorTheme) => any;
+    theme: EditorTheme;
+}
+export interface EditorThemePreferencesWidgetState {
+    theme: EditorTheme;
+    modified: boolean;
+}
+export declare const fromCamelCaseToSentence: ((word: any) => string) & _.MemoizedFunction;
+export declare enum ThemeTableColumns {
+    COLOR = "color",
+    IDENT = "ident",
+    DESC = "desc"
+}
+export declare class EditorThemePreferencesWidget extends React.Component<EditorThemePreferencesWidgetProps, EditorThemePreferencesWidgetState> {
+    accessor comboBoxStore: ComboBoxStore;
+    accessor monacoThemeStore: MonacoThemeStore;
+    constructor(props: EditorThemePreferencesWidgetProps);
+    getRGBA(c: any): any;
+    deleteTheme: () => void;
+    render(): React.JSX.Element;
+}

package/dist/@types/theme/SmartEditorThemePreferencesWidget.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { ComboBoxStore } from '@journeyapps-labs/reactor-mod';
+import { MonacoThemeStore } from '../stores/MonacoThemeStore';
+export declare class SmartEditorThemePreferencesWidget extends React.Component {
+    accessor comboBoxStore: ComboBoxStore;
+    accessor monacoThemeStore: MonacoThemeStore;
+    render(): React.JSX.Element;
+}

package/dist/@types/theme/UploadVSIXThemeBtnWidget.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { ComboBoxStore, MousePosition } from '@journeyapps-labs/reactor-mod';
+import { VSIXTheme } from './theme-utils';
+export interface EditorThemePreferencesWidgetProps {
+    gotTheme: (theme: VSIXTheme) => any;
+}
+export declare class UploadVSIXThemeBtnWidget extends React.Component<EditorThemePreferencesWidgetProps> {
+    accessor comboBoxStore: ComboBoxStore;
+    constructor(props: EditorThemePreferencesWidgetProps);
+    doUpload(event: MousePosition, file: File): Promise<void>;
+    render(): React.JSX.Element;
+}

package/dist/@types/theme/patchThemeService.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Patch standaloneThemeService to implement semantic highlighting.
+ *
+ * This may eventually become redundant when Monaco implements proper support.
+ *
+ * Based on: https://github.com/TypeFox/monaco-languageclient/issues/209#issuecomment-619531624
+ * Tracking feature: https://github.com/microsoft/monaco-editor/issues/1833
+ */
+export declare function patchThemeService(): void;

package/dist/@types/theme/theme-utils.d.ts

@@ -0,0 +1,61 @@
+import * as monaco from 'monaco-editor';
+export type ColorContribution = {
+    id: string;
+    description: string;
+    defaults: {
+        dark: string;
+        light: string;
+        hc: string;
+    };
+    needsTransparency: boolean;
+    deprecationMessage: string;
+};
+export type ColorSchema = {
+    description: string;
+};
+export type ColorRegistry = {
+    colorsById: {
+        [id: string]: ColorContribution;
+    };
+    colorSchema: {
+        properties: {
+            [id: string]: ColorSchema;
+        };
+    };
+};
+export type TokenColor = {
+    name: string;
+    scope: string;
+    settings: {
+        fontStyle: string;
+        foreground: string;
+        background: string;
+    };
+};
+export type VSIXTheme = {
+    name: string;
+    tokenColors: TokenColor[];
+    colors: {
+        [key: string]: string;
+    };
+};
+export type VSIXPackage = {
+    contributes: {
+        themes: {
+            label: string;
+            path: string;
+            uiTheme: string;
+        }[];
+    };
+};
+export declare const normalizeVSCodeTheme: (themeObject: VSIXTheme) => monaco.editor.IStandaloneThemeData;
+export declare const colorRegistry: ColorRegistry;
+export declare const DARK_THEME = "journey-dark";
+export declare const COUPLED_IDE_THEMES: {
+    journey: monaco.editor.IStandaloneThemeData;
+    reactor: monaco.editor.IStandaloneThemeData;
+    oxide: monaco.editor.IStandaloneThemeData;
+    scarlet: monaco.editor.IStandaloneThemeData;
+    hexagon: monaco.editor.IStandaloneThemeData;
+    "reactor-light": monaco.editor.IStandaloneThemeData;
+};

package/dist/@types/theme-reactor/editor-theme-fragment.d.ts

@@ -0,0 +1,41 @@
+import { ThemeFragment } from '@journeyapps-labs/reactor-mod';
+export declare const theme: ThemeFragment<{
+    editor: {
+        label: string;
+        colors: {
+            background: string;
+            backgroundSticky: string;
+        };
+    };
+}>;
+export declare const Scarlet: import("@journeyapps-labs/reactor-mod").ThemeColors<{
+    editor: {
+        label: string;
+        colors: {
+            background: string;
+            backgroundSticky: string;
+        };
+    };
+}>;
+export declare const styled: import("@journeyapps-labs/reactor-mod").CreateStyled<import("@journeyapps-labs/reactor-mod").ThemeColors<{
+    editor: {
+        label: string;
+        colors: {
+            background: string;
+            backgroundSticky: string;
+        };
+    };
+}> & {
+    light: boolean;
+}>;
+export declare const themed: import("@journeyapps-labs/reactor-mod").CreateStyled<import("@journeyapps-labs/reactor-mod").ThemeColors<{
+    editor: {
+        label: string;
+        colors: {
+            background: string;
+            backgroundSticky: string;
+        };
+    };
+}> & {
+    light: boolean;
+}>;

package/dist/@types/utils/paths.d.ts

@@ -0,0 +1,23 @@
+import type * as monaco from 'monaco-editor';
+export interface BranchFile {
+    appID: string;
+    branch: string;
+    path: string;
+}
+/**
+ * Take a Monaco model URI, and covert it to a path in the local repo.
+ * If the URI does not reference a valid local path, null is returned.
+ * No checks are performed on whether or not the referenced file exists.
+ */
+export declare const uriToPath: (uri: monaco.Uri) => BranchFile | null;
+/**
+ * Given a local filename, return a monaco Uri.
+ * @param path The local path, e.g. schema.xml or mobile/main.js
+ */
+export declare function pathToUri(path: BranchFile, _monaco: typeof monaco): monaco.Uri;
+/**
+ * Given a path or filename return a language based on the file extension. Optionally accepts a file_length
+ * parameter (1 char = 2 bytes) which, if too large, will result in 'text' being returned regardless of
+ * language
+ */
+export declare function getLanguageFromFile(file: string, file_length?: number): "css" | "markdown" | "python" | "text" | "json" | "javascript" | "xml" | "jxml" | "html" | "yaml" | "typescript" | "handlebars";

package/dist/@types/utils/useEditorStickyHeader.d.ts

@@ -0,0 +1,8 @@
+import * as monaco from 'monaco-editor';
+export interface UseEditorStickyHeaderOptions {
+    editor: monaco.editor.IStandaloneCodeEditor;
+}
+export declare const useEditorStickyHeader: (props: UseEditorStickyHeaderOptions) => {
+    zIndex: number;
+    lines: number;
+};

package/dist/@types/widgets/DualEditorWidget.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { MonacoDiffEditorProps } from 'react-monaco-editor';
+export interface DualEditorWidgetProps extends MonacoDiffEditorProps {
+    getLeftHeaderContent: () => React.JSX.Element;
+    getRightHeaderContent: () => React.JSX.Element;
+}
+export declare const DualEditorWidget: React.FC<DualEditorWidgetProps>;