jsx-repl 0.0.1 → 0.0.5

package/dist/src/Message.d.ts

@@ -0,0 +1,63 @@
+declare const _default: (__props: typeof __ctx.props & {
+    err?: string | Error | false;
+    warn?: string | Error;
+}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: ({ err, warn }: {
+    err?: string | Error | false;
+    warn?: string | Error;
+}) => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VaporRenderResult<import("vue").Block>[] | import("vue").VaporComponentInstance<Readonly<import("vue").TransitionProps & {}>, {}, {
+        [x: string]: (...args: any[]) => import("vue").Block;
+    }, Record<string, any>, Node, Record<string, any>> | import("vue").VaporComponentInstance<Readonly<import("vue").TransitionProps & {}>, {}, {
+        [x: string]: (...args: any[]) => import("vue").Block;
+    }, Record<string, any>, import("vue").VaporFragment<import("vue").Block>, Record<string, any>> | import("vue").VaporComponentInstance<Readonly<import("vue").TransitionProps & {}>, {}, {
+        [x: string]: (...args: any[]) => import("vue").Block;
+    }, Record<string, any>, {
+        anchor: Node;
+        scope: import("vue").EffectScope | undefined;
+        current?: (...args: any[]) => import("vue").Block;
+        pending?: {
+            render?: (...args: any[]) => import("vue").Block;
+            key: any;
+        };
+        fallback?: (...args: any[]) => import("vue").Block;
+        anchorLabel?: string;
+        keyed?: boolean;
+        attrs?: Record<string, any>;
+        setAsyncRef?: (instance: import("vue").VaporComponentInstance) => void;
+        getScope?: (key: any) => import("vue").EffectScope | undefined;
+        onBeforeTeardown?: ((oldKey: any, nodes: import("vue").Block, scope: import("vue").EffectScope) => boolean)[];
+        onBeforeMount?: ((newKey: any, nodes: import("vue").Block, scope: import("vue").EffectScope) => void)[];
+        slotOwner: import("vue").VaporComponentInstance | null;
+        update(render?: (...args: any[]) => import("vue").Block, key?: any): void;
+        renderBranch(render: ((...args: any[]) => import("vue").Block) | undefined, transition: import("vue").VaporTransitionHooks | undefined, parent: ParentNode | null, instance: import("vue").GenericComponentInstance | null): void;
+        hydrate: (isEmpty?: boolean) => void;
+        $key?: any;
+        $transition?: import("vue").VaporTransitionHooks | undefined;
+        nodes: import("vue").Block;
+        vnode?: VNode | null;
+        parentComponent?: import("vue").GenericComponentInstance | null;
+        insert?: (parent: ParentNode, anchor: Node | null, transitionHooks?: import("vue").TransitionHooks) => void;
+        remove?: (parent?: ParentNode, transitionHooks?: import("vue").TransitionHooks) => void;
+        setRef?: (instance: import("vue").VaporComponentInstance, ref: string | globalThis.Ref<any, any> | ((ref: Element | import("vue").VaporComponentInstance, refs: Record<string, any>) => void), refFor: boolean, refKey: string | undefined) => void;
+        onUpdated?: ((nodes?: import("vue").Block) => void)[];
+    }, Record<string, any>> | import("vue").VaporComponentInstance<Readonly<import("vue").TransitionProps & {}>, {}, {
+        [x: string]: (...args: any[]) => import("vue").Block;
+    }, Record<string, any>, import("vue").VaporComponentInstance<{}, {}, {
+        [x: string]: (...args: any[]) => import("vue").Block;
+    }, Record<string, any>, import("vue").Block, Record<string, any>>, Record<string, any>> | import("vue").VaporComponentInstance<Readonly<import("vue").TransitionProps & {}>, {}, {
+        [x: string]: (...args: any[]) => import("vue").Block;
+    }, Record<string, any>, import("vue").Block[], Record<string, any>>;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/Repl.d.ts

@@ -0,0 +1,58 @@
+import { type Store } from './store';
+import { type EditorComponentType } from './types';
+import type * as monaco from 'monaco-editor-core';
+import 'floating-vue/dist/style.css';
+import './dropdown.css';
+export interface Props {
+    previewTheme?: boolean;
+    editor?: EditorComponentType;
+    autoResize?: boolean;
+    autoSave?: boolean;
+    showCompileOutput?: boolean;
+    clearConsole?: boolean;
+    store?: Store;
+    layout?: 'horizontal' | 'vertical';
+    slim?: boolean;
+    ssr?: boolean;
+    theme?: 'dark' | 'light';
+    previewOptions?: {
+        headHTML?: string;
+        bodyHTML?: string;
+        placeholderHTML?: string;
+        customCode?: {
+            importCode?: string;
+            useCode?: string;
+        };
+        showRuntimeError?: boolean;
+        showRuntimeWarning?: boolean;
+    };
+    editorOptions?: {
+        showErrorText?: string | false;
+        virtualFilesText?: string | false;
+        sourceMapText?: string | false;
+        autoSaveText?: string | false;
+        monacoOptions?: monaco.editor.IStandaloneEditorConstructionOptions;
+    };
+    splitPaneOptions?: {
+        codeTogglerText?: string;
+        outputTogglerText?: string;
+    };
+}
+export declare const Repl: (__props: typeof __ctx.props & Props, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: ({ previewTheme, autoResize, showCompileOutput, clearConsole, ssr, autoSave, layout, previewOptions, editorOptions, splitPaneOptions, editor, slim, theme, }: Props) => {
+    props: {
+        modelValue: import("vue").UnwrapRef<import("vue").ModelRef<string, string, string, string>>;
+        "onUpdate:modelValue"?: ($event: import("vue").UnwrapRef<import("vue").ModelRef<string, string, string, string>>) => any;
+    };
+    context: {
+        slots: {};
+        expose: (exposed: {
+            reload: () => void;
+        }) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};

package/dist/src/SplitPane.d.ts

@@ -0,0 +1,24 @@
+import type { Props } from './Repl';
+declare const _default: (__props: typeof __ctx.props & {
+    layout?: Props["layout"];
+    inline?: boolean;
+}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: (props: {
+    layout?: Props["layout"];
+    inline?: boolean;
+}) => {
+    props: {};
+    context: {
+        slots: Partial<{
+            left: () => JSX.Element;
+            right: () => JSX.Element;
+        }>;
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/editor/EditorContainer.d.ts

@@ -0,0 +1,19 @@
+import { type EditorComponentType } from '../types';
+declare const _default: (__props: typeof __ctx.props & {
+    editorComponent: EditorComponentType;
+}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: (props: {
+    editorComponent: EditorComponentType;
+}) => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: JSX.Element;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/editor/FileSelector.d.ts

@@ -0,0 +1,23 @@
+import { type ReplFile } from '../store';
+declare const _default: (__props: typeof __ctx.props & {
+    files: Record<string, ReplFile>;
+    activeFile: ReplFile;
+    disabled?: boolean;
+}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: (props: {
+    files: Record<string, ReplFile>;
+    activeFile: ReplFile;
+    disabled?: boolean;
+}) => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/editor/ToggleButton.d.ts

@@ -0,0 +1,20 @@
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: ({ text }: {
+    text?: string | undefined;
+}) => {
+    props: {
+        modelValue?: import("vue").UnwrapRef<import("vue").ModelRef<boolean | undefined, string, boolean | undefined, boolean | undefined>>;
+        "onUpdate:modelValue"?: ($event: import("vue").UnwrapRef<import("vue").ModelRef<boolean | undefined, string, boolean | undefined, boolean | undefined>>) => any;
+        text?: typeof text;
+    };
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/editor/sourceMap.d.ts

@@ -0,0 +1 @@
+export declare const useSourceMap: () => void;

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+import 'uno.css';
+export { Repl } from './Repl';
+export { default as Preview } from './output/Preview';
+export { useStore, ReplFile, type StoreState, type Store, type ReplStore, type ImportMap, } from './store';
+export { compileFile } from './transform';
+export type { Props as ReplProps } from './Repl';
+export type { OutputModes } from './types';
+export { serialize } from './utils';

package/dist/src/monaco/Monaco.d.ts

@@ -0,0 +1,30 @@
+import * as monaco from 'monaco-editor-core';
+import { type EditorMode } from '../types';
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: ({ filename, readonly, value, mode, onChange, }: {
+    filename?: string | undefined;
+    readonly?: boolean | undefined;
+    value?: string | undefined;
+    mode?: EditorMode | undefined;
+    onChange?: ((value: string) => void) | undefined;
+}) => {
+    props: {
+        filename: typeof filename;
+        readonly?: typeof readonly;
+        value?: typeof value;
+        mode?: typeof mode;
+        onChange?: typeof onChange;
+    };
+    context: {
+        slots: {};
+        expose: (exposed: {
+            editor: monaco.editor.IStandaloneCodeEditor | undefined;
+        }) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/monaco/env.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from '../store';
+export declare function initMonaco(store: Store): void;
+export declare class WorkerHost {
+    onFetchCdnFile(uri: string, text: string): void;
+}
+export declare function reloadLanguageTools(store: Store): Promise<void>;
+export interface WorkerMessage {
+    event: 'init';
+    tsVersion: string;
+    tsLocale?: string;
+    tsMacroConfig: string;
+}
+export declare function loadMonacoEnv(store: Store): void;

package/dist/src/monaco/highlight.d.ts

@@ -0,0 +1,4 @@
+export declare function registerHighlighter(): {
+    light: string;
+    dark: string;
+};

package/dist/src/monaco/language-configs.d.ts

@@ -0,0 +1,5 @@
+import { languages } from 'monaco-editor-core';
+export declare const html: languages.LanguageConfiguration;
+export declare const css: languages.LanguageConfiguration;
+export declare const js: languages.LanguageConfiguration;
+export declare const ts: languages.LanguageConfiguration;

package/dist/src/monaco/utils.d.ts

@@ -0,0 +1,2 @@
+import { type Uri, editor } from 'monaco-editor-core';
+export declare function getOrCreateModel(uri: Uri, lang: string | undefined, value: string): editor.ITextModel;

package/dist/src/monaco/worker.d.ts

@@ -0,0 +1,7 @@
+export interface CreateData {
+    tsconfig: {
+        compilerOptions?: import('typescript').CompilerOptions;
+    };
+    tsMacroConfig: any;
+    dependencies: Record<string, string>;
+}

package/dist/src/output/Devtools.d.ts

@@ -0,0 +1,20 @@
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: ({ previewContainer, theme, }: {
+    previewContainer?: HTMLDivElement | null | undefined;
+    theme?: "dark" | "light" | undefined;
+}) => {
+    props: {
+        previewContainer?: typeof previewContainer;
+        theme?: typeof theme;
+    };
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/output/Output.d.ts

@@ -0,0 +1,29 @@
+import { type EditorComponentType } from '../types';
+declare const _default: (__props: typeof __ctx.props & {
+    editorComponent: EditorComponentType;
+    showCompileOutput?: boolean;
+    ssr: boolean;
+}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: (props: {
+    editorComponent: EditorComponentType;
+    showCompileOutput?: boolean;
+    ssr: boolean;
+}) => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: {
+            reload: () => void;
+            previewRef: {
+                reload: () => void;
+                container: HTMLDivElement | null | undefined;
+            } | null | undefined;
+        }) => void;
+        attrs: Record<string, any>;
+    };
+    render: JSX.Element;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/output/Preview.d.ts

@@ -0,0 +1,21 @@
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: ({ ssr }: {
+    ssr?: boolean | undefined;
+}) => {
+    props: {
+        ssr?: typeof ssr;
+    };
+    context: {
+        slots: {};
+        expose: (exposed: {
+            reload: () => void;
+            container: HTMLDivElement | null | undefined;
+        }) => void;
+        attrs: Record<string, any>;
+    };
+    render: JSX.Element;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/output/PreviewProxy.d.ts

@@ -0,0 +1,16 @@
+export declare class PreviewProxy {
+    iframe: HTMLIFrameElement;
+    handlers: Record<string, Function>;
+    pending_cmds: Map<number, {
+        resolve: (value: unknown) => void;
+        reject: (reason?: any) => void;
+    }>;
+    handle_event: (e: any) => void;
+    constructor(iframe: HTMLIFrameElement, handlers: Record<string, Function>);
+    destroy(): void;
+    iframe_command(action: string, args: any): Promise<unknown>;
+    handle_command_message(cmd_data: any): void;
+    handle_repl_message(event: any): any;
+    eval(script: string | string[]): Promise<unknown>;
+    handle_links(): Promise<unknown>;
+}

package/dist/src/output/SourceMap.d.ts

@@ -0,0 +1,14 @@
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: () => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: JSX.Element;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/output/diff.d.ts

@@ -0,0 +1 @@
+export declare const useDiff: () => void;

package/dist/src/output/download.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from '../store';
+export declare function downloadProject(store: Store): Promise<void>;

package/dist/src/output/moduleCompiler.d.ts

@@ -0,0 +1,2 @@
+import { type Store } from '../store';
+export declare function compileModulesForPreview(store: Store, isSSR?: boolean): string[];

package/dist/src/output/user/Login.d.ts

@@ -0,0 +1,14 @@
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: () => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: JSX.Element;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/output/user/Project.d.ts

@@ -0,0 +1,14 @@
+declare const _default: (__props: typeof __ctx.props & {}, __context?: typeof __ctx.context, __ctx?: Awaited<ReturnType<typeof __fn>>, __fn?: () => {
+    props: {};
+    context: {
+        slots: {};
+        expose: (exposed: Record<string, any>) => void;
+        attrs: Record<string, any>;
+    };
+    render: HTMLDivElement;
+}) => typeof __ctx.render & {
+    __ctx?: {
+        props: typeof __ctx.props;
+    } & typeof __ctx.context;
+};
+export default _default;

package/dist/src/presets/index.d.ts

@@ -0,0 +1,128 @@
+export declare const packageFile = "package.json";
+export declare const tsconfigFile = "tsconfig.json";
+export declare const viteConfigFile = "vite.config.ts";
+export declare const tsMacroConfigFile = "ts-macro.config.ts";
+export declare const indexHtmlFile = "src/index.html";
+export declare const appFile = "src/App.tsx";
+export declare const defaultPresets: {
+    'vue-jsx': {
+        "src/index.html": {
+            code: string;
+        };
+        "src/App.tsx": {
+            code: string;
+        };
+        "vite.config.ts": {
+            code: string;
+        };
+        "ts-macro.config.ts": {
+            code: string;
+        };
+        "tsconfig.json": {
+            code: string;
+        };
+        "package.json": {
+            code: string;
+        };
+    };
+    'vue-jsx-vapor': {
+        "src/index.html": {
+            code: string;
+        };
+        "src/App.tsx": {
+            code: string;
+        };
+        "vite.config.ts": {
+            code: string;
+        };
+        "ts-macro.config.ts": {
+            code: string;
+        };
+        "tsconfig.json": {
+            code: string;
+        };
+        "package.json": {
+            code: string;
+        };
+    };
+    'vue-jsx-babel': {
+        "src/index.html": {
+            code: string;
+        };
+        "src/App.tsx": {
+            code: string;
+        };
+        "vite.config.ts": {
+            code: string;
+        };
+        "ts-macro.config.ts": {
+            code: string;
+        };
+        "tsconfig.json": {
+            code: string;
+        };
+        "package.json": {
+            code: string;
+        };
+    };
+    react: {
+        "src/index.html": {
+            code: string;
+        };
+        "src/App.tsx": {
+            code: string;
+        };
+        "vite.config.ts": {
+            code: string;
+        };
+        "ts-macro.config.ts": {
+            code: string;
+        };
+        "tsconfig.json": {
+            code: string;
+        };
+        "package.json": {
+            code: string;
+        };
+    };
+    preact: {
+        "src/index.html": {
+            code: string;
+        };
+        "src/App.tsx": {
+            code: string;
+        };
+        "vite.config.ts": {
+            code: string;
+        };
+        "ts-macro.config.ts": {
+            code: string;
+        };
+        "tsconfig.json": {
+            code: string;
+        };
+        "package.json": {
+            code: string;
+        };
+    };
+    solid: {
+        "src/index.html": {
+            code: string;
+        };
+        "src/App.tsx": {
+            code: string;
+        };
+        "vite.config.ts": {
+            code: string;
+        };
+        "ts-macro.config.ts": {
+            code: string;
+        };
+        "tsconfig.json": {
+            code: string;
+        };
+        "package.json": {
+            code: string;
+        };
+    };
+};