nuxt-codemirror 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Thimo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+
+
+# Nuxt CodeMirror
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+Codemirror as a Nuxt module. Demo preview: Coming soon
+
+
+- [✨  Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/my-module?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+
+## Features
+
+<!-- Highlight some of the features your module provide here -->
+- 🚀 Easily configure codemirror to your own needs using almost every API
+- 🚠 Built with Typescript
+- 🌲 Custom useNuxtCodeMirror composable for creating your own editor
+- Built for CodeMirror 6 and above
+
+## Quick Setup
+
+Install the module to your Nuxt application with one command:
+
+```bash
+npx nuxi module add thimodev/nuxt-codemirror
+```
+
+That's it! You can now use Nuxt-codemirror in your Nuxt app ✨
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+
+  ```bash
+  # Install dependencies
+  pnpm i
+
+  # Generate type stubs
+  pnpm dev:prepare
+
+  # Develop with the playground
+  pnpm dev
+
+  # Build the playground
+  pnpm dev:build
+
+  # Run ESLint
+  pnpm lint
+
+  # Run Vitest
+  pnpm test
+  pnpm test:watch
+
+  # Release new version
+  pnpm release
+  ```
+
+</details>
+
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/my-module/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/my-module
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/my-module.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npmjs.com/package/my-module
+
+[license-src]: https://img.shields.io/npm/l/my-module.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/my-module
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
+[nuxt-href]: https://nuxt.com
+
+
+
+## FAQ
+
+- I get an extension duplicate error:  Fix Unrecognized extension value in extension set ([object Object]). This sometimes happens because multiple instances of @codemirror/state are loaded, breaking instanceof checks.
+
+For now write shamefully-hoist=true in your .npmrc file to solve this. We are working on a better solution

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,7 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.d.ts

@@ -0,0 +1,7 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-codemirror",
+  "configKey": "nuxtCodemirror",
+  "version": "0.0.1",
+  "builder": {
+    "@nuxt/module-builder": "0.8.1",
+    "unbuild": "2.0.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,28 @@
+import { defineNuxtModule, createResolver, addComponent, addImports, addTypeTemplate } from '@nuxt/kit';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "nuxt-codemirror",
+    configKey: "nuxtCodemirror"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {},
+  setup(_options, _nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    addComponent({
+      name: "NuxtCodeMirror",
+      filePath: resolve("./runtime/components/NuxtCodeMirror.vue")
+    });
+    addImports({
+      name: "useNuxtCodeMirror",
+      as: "useNuxtCodeMirror",
+      from: resolve("./runtime/composables/useNuxtCodeMirror.ts")
+    });
+    addTypeTemplate({
+      filename: "../runtime/types/nuxt-codemirror.d.ts",
+      src: resolve("./runtime/types/nuxt-codemirror.d.ts")
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/components/NuxtCodeMirror.vue

@@ -0,0 +1,77 @@
+<script setup lang="ts">
+import type { ViewUpdate, EditorView } from '@codemirror/view'
+import type { EditorState } from '@codemirror/state'
+import { useNuxtCodeMirror } from '../composables/useNuxtCodeMirror'
+import type { NuxtCodeMirrorProps, Statistics } from '../types/nuxt-codemirror'
+import { onMounted, ref, watch, nextTick, computed } from '#imports'
+
+const editor = ref<HTMLDivElement | null>(null)
+const container = ref<HTMLDivElement | null>(null)
+const view = ref<EditorView>()
+const state = ref<EditorState>()
+
+const modelValue = defineModel<string>({ default: '' })
+
+const props = withDefaults(defineProps<Omit<NuxtCodeMirrorProps, 'modelValue'>>(), {
+  extensions: () => [],
+  theme: 'light',
+})
+
+defineExpose({
+  container,
+  view,
+  state,
+  editor,
+})
+
+const emit = defineEmits<{
+  (event: 'onChange', value: string, viewUpdate: ViewUpdate): void
+  (event: 'onStatistics', data: Statistics): void
+  (event: 'onCreateEditor', editor: { view: EditorView, state: EditorState }): void
+  (event: 'onUpdate' | 'onFocus' | 'onBlur', update: ViewUpdate): void
+}>()
+
+onMounted(async () => {
+  await nextTick()
+
+  useNuxtCodeMirror({
+    ...props,
+    modelValue: modelValue.value,
+    onChange: (value, viewUpdate) => {
+      modelValue.value = value
+      emit('onChange', value, viewUpdate)
+    },
+    onStatistics: data => emit('onStatistics', data),
+    onCreateEditor: (view, state) => emit('onCreateEditor', { view, state }),
+    onUpdate: viewUpdate => emit('onUpdate', viewUpdate),
+    onFocus: viewUpdate => emit('onFocus', viewUpdate),
+    onBlur: viewUpdate => emit('onBlur', viewUpdate),
+    container: editor.value,
+    viewRef: view,
+    stateRef: state,
+    containerRef: container,
+  })
+
+  /** DEBUGGING the variables exposed by defineExpose */
+  // await nextTick()
+  // console.log('test: ', view.value)
+})
+
+watch(() => modelValue, (newValue) => {
+  if (typeof newValue !== 'string') {
+    console.error(`value must be typeof string but got ${typeof newValue}`)
+  }
+})
+
+const defaultClassNames = computed(() =>
+  typeof props.theme === 'string' ? `cm-theme-${props.theme}` : 'cm-theme',
+)
+</script>
+
+<template>
+  <div
+    ref="editor"
+    :class="`${defaultClassNames}${$attrs.class ? ` ${$attrs.class}` : ''}`"
+    v-bind="$attrs"
+  />
+</template>

package/dist/runtime/composables/useNuxtCodeMirror.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { type UseCodeMirrorProps } from '../types/nuxt-codemirror.js';
+export declare function useNuxtCodeMirror(props: UseCodeMirrorProps): {
+    containerRef: import("#imports").Ref<HTMLDivElement | null>;
+    viewRef: import("#imports").Ref<EditorView | undefined>;
+    stateRef: import("#imports").Ref<EditorState | undefined>;
+};

package/dist/runtime/composables/useNuxtCodeMirror.js

@@ -0,0 +1,160 @@
+import { Annotation, EditorState, StateEffect } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { getDefaultExtensions } from "../getDefaultExtensions.js";
+import { getStatistics } from "../utils/utils.js";
+import { onBeforeUnmount, watch, watchEffect } from "#imports";
+const External = Annotation.define();
+const emptyExtensions = [];
+export function useNuxtCodeMirror(props) {
+  const {
+    // modelValue = '',
+    selection,
+    onChange,
+    onStatistics,
+    onCreateEditor,
+    onUpdate,
+    onFocus,
+    onBlur,
+    extensions = emptyExtensions,
+    autoFocus,
+    theme = "light",
+    height = null,
+    minHeight = null,
+    maxHeight = null,
+    width = null,
+    minWidth = null,
+    maxWidth = null,
+    placeholder: placeholderStr = "",
+    editable = true,
+    readOnly = false,
+    indentWithTab: defaultIndentWithTab = true,
+    basicSetup: defaultBasicSetup = true,
+    root,
+    initialState,
+    containerRef,
+    viewRef,
+    stateRef
+  } = props;
+  const defaultThemeOption = EditorView.theme({
+    "&": {
+      height,
+      minHeight,
+      maxHeight,
+      width,
+      minWidth,
+      maxWidth
+    },
+    "& .cm-scroller": {
+      height: "100% !important"
+    }
+  });
+  const updateListener = EditorView.updateListener.of((viewUpdate) => {
+    if (viewUpdate.docChanged && typeof onChange === "function" && !viewUpdate.transactions.some((tr) => tr.annotation(External))) {
+      const doc = viewUpdate.state.doc;
+      const value = doc.toString();
+      onChange(value, viewUpdate);
+    }
+    if (viewUpdate.focusChanged) {
+      viewUpdate.view.hasFocus ? onFocus && onFocus(viewUpdate) : onBlur && onBlur(viewUpdate);
+    }
+    onStatistics && onStatistics(getStatistics(viewUpdate));
+  });
+  const defaultExtensions = getDefaultExtensions({
+    theme,
+    editable,
+    readOnly,
+    placeholder: placeholderStr,
+    indentWithTab: defaultIndentWithTab,
+    basicSetup: defaultBasicSetup
+  });
+  let getExtensions = [updateListener, defaultThemeOption, ...defaultExtensions];
+  if (onUpdate && typeof onUpdate === "function") {
+    getExtensions.push(EditorView.updateListener.of(onUpdate));
+  }
+  getExtensions = getExtensions.concat(extensions);
+  watchEffect(() => {
+    if (containerRef.value && !stateRef?.value) {
+      const config = {
+        doc: props.modelValue,
+        selection,
+        extensions: getExtensions
+      };
+      const stateCurrent = initialState ? EditorState.fromJSON(initialState.json, config, initialState.fields) : EditorState.create(config);
+      stateRef.value = stateCurrent;
+      if (!viewRef.value) {
+        const viewCurrent = new EditorView({
+          state: stateCurrent,
+          parent: containerRef.value,
+          root
+        });
+        viewRef.value = viewCurrent;
+        onCreateEditor && onCreateEditor(viewCurrent, stateCurrent);
+      }
+    }
+  });
+  watch(
+    () => props.container,
+    (newContainer) => {
+      if (newContainer === void 0) return;
+      containerRef.value = newContainer;
+    },
+    { immediate: true }
+  );
+  watch(
+    [
+      () => theme,
+      () => extensions,
+      () => height,
+      () => minHeight,
+      () => maxHeight,
+      () => width,
+      () => minWidth,
+      () => maxWidth,
+      () => placeholderStr,
+      () => editable,
+      () => readOnly,
+      () => defaultIndentWithTab,
+      () => defaultBasicSetup,
+      () => onChange,
+      () => onUpdate
+    ],
+    () => {
+      if (viewRef.value) {
+        viewRef.value.dispatch({ effects: StateEffect.reconfigure.of(getExtensions) });
+      }
+    },
+    { immediate: true }
+  );
+  watchEffect(() => {
+    if (props.modelValue === void 0) {
+      return;
+    }
+    const currentValue = viewRef.value ? viewRef.value.state.doc.toString() : "";
+    if (viewRef.value && props.modelValue !== currentValue) {
+      viewRef.value.dispatch({
+        changes: { from: 0, to: currentValue.length, insert: props.modelValue || "" },
+        annotations: [External.of(true)]
+      });
+    }
+  });
+  watch(
+    [() => autoFocus, () => viewRef.value],
+    ([autoFocus2, view]) => {
+      if (autoFocus2 && view) {
+        view.focus();
+      }
+    },
+    { immediate: true }
+  );
+  onBeforeUnmount(() => {
+    if (viewRef) {
+      viewRef.value?.destroy();
+      viewRef.value = void 0;
+    }
+  });
+  return {
+    containerRef,
+    viewRef,
+    stateRef
+  };
+}

package/dist/runtime/getDefaultExtensions.d.ts

@@ -0,0 +1,13 @@
+import { type Extension } from '@codemirror/state';
+import { type BasicSetupOptions } from '@uiw/codemirror-extensions-basic-setup';
+export * from '@codemirror/theme-one-dark';
+export * from './theme/light.js';
+export interface DefaultExtensionsOptions {
+    indentWithTab?: boolean;
+    basicSetup?: boolean | BasicSetupOptions;
+    placeholder?: string | HTMLElement;
+    theme?: 'light' | 'dark' | 'none' | Extension;
+    readOnly?: boolean;
+    editable?: boolean;
+}
+export declare const getDefaultExtensions: (optios?: DefaultExtensionsOptions) => Extension[];

package/dist/runtime/getDefaultExtensions.js

@@ -0,0 +1,52 @@
+import { indentWithTab } from "@codemirror/commands";
+import { basicSetup } from "@uiw/codemirror-extensions-basic-setup";
+import { EditorView, keymap, placeholder } from "@codemirror/view";
+import { oneDark } from "@codemirror/theme-one-dark";
+import { EditorState } from "@codemirror/state";
+import { defaultLightThemeOption } from "./theme/light.js";
+export * from "@codemirror/theme-one-dark";
+export * from "./theme/light.js";
+export const getDefaultExtensions = (optios = {}) => {
+  const {
+    indentWithTab: defaultIndentWithTab = true,
+    editable = true,
+    readOnly = false,
+    theme = "light",
+    placeholder: placeholderStr = "",
+    basicSetup: defaultBasicSetup = true
+  } = optios;
+  const getExtensions = [];
+  if (defaultIndentWithTab) {
+    getExtensions.unshift(keymap.of([indentWithTab]));
+  }
+  if (defaultBasicSetup) {
+    if (typeof defaultBasicSetup === "boolean") {
+      getExtensions.unshift(basicSetup());
+    } else {
+      getExtensions.unshift(basicSetup(defaultBasicSetup));
+    }
+  }
+  if (placeholderStr) {
+    getExtensions.unshift(placeholder(placeholderStr));
+  }
+  switch (theme) {
+    case "light":
+      getExtensions.push(defaultLightThemeOption);
+      break;
+    case "dark":
+      getExtensions.push(oneDark);
+      break;
+    case "none":
+      break;
+    default:
+      getExtensions.push(theme);
+      break;
+  }
+  if (editable === false) {
+    getExtensions.push(EditorView.editable.of(false));
+  }
+  if (readOnly) {
+    getExtensions.push(EditorState.readOnly.of(true));
+  }
+  return [...getExtensions];
+};

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,4 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((_nuxtApp) => {
+  console.log("Plugin injected by my-module!");
+});

package/dist/runtime/theme/light.d.ts

@@ -0,0 +1 @@
+export declare const defaultLightThemeOption: import("@codemirror/state").Extension;

package/dist/runtime/theme/light.js

@@ -0,0 +1,11 @@
+import { EditorView } from "@codemirror/view";
+export const defaultLightThemeOption = EditorView.theme(
+  {
+    "&": {
+      backgroundColor: "#fff"
+    }
+  },
+  {
+    dark: false
+  }
+);

package/dist/runtime/types/nuxt-codemirror.d.ts

@@ -0,0 +1,123 @@
+import type { EditorState, EditorStateConfig, Extension, StateField, EditorSelection, SelectionRange, Line } from '@codemirror/state'
+import type { EditorView, ViewUpdate } from '@codemirror/view'
+import type { BasicSetupOptions } from '@uiw/codemirror-extensions-basic-setup'
+import type { Ref } from '#imports'
+
+export interface NuxtCodeMirrorProps
+  extends Omit<EditorStateConfig, 'doc' | 'extensions'> {
+  /** value of the auto created model in the editor. */
+  modelValue?: string
+  height?: string
+  minHeight?: string
+  maxHeight?: string
+  width?: string
+  minWidth?: string
+  maxWidth?: string
+  /** focus on the editor. */
+  autoFocus?: boolean
+  /** Enables a placeholder—a piece of example content to show when the editor is empty. */
+  placeholder?: string | HTMLElement
+  /**
+   * `light` / `dark` / `Extension` Defaults to `light`.
+   * @default light
+   */
+  theme?: 'light' | 'dark' | 'none' | Extension
+  /**
+   * Whether to optional basicSetup by default
+   * @default true
+   */
+  basicSetup?: boolean | BasicSetupOptions
+  /**
+   * This disables editing of the editor content by the user.
+   * @default true
+   */
+  editable?: boolean
+  /**
+   * This disables editing of the editor content by the user.
+   * @default false
+   */
+  readOnly?: boolean
+  /**
+   * Controls whether pressing the `Tab` key inserts a tab character and indents the text (`true`)
+   * or behaves according to the browser's default behavior (`false`).
+   * @default true
+   */
+  indentWithTab?: boolean
+  /** Fired whenever a change occurs to the document. */
+  onChange?(value: string, viewUpdate: ViewUpdate): void
+  /** Some data on the statistics editor. */
+  onStatistics?(data: Statistics): void
+  /** Fired whenever any state change occurs within the editor, including non-document changes like lint results. */
+  onUpdate?(viewUpdate: ViewUpdate): void
+  /** The first time the editor executes the event. */
+  onCreateEditor?(view: EditorView, state: EditorState): void
+  /** Fired whenever the editor is focused. */
+  onFocus?(view: ViewUpdate): void
+  /** Fired whenever the editor is blurred. */
+  onBlur?(view: ViewUpdate): void
+  /**
+   * Extension values can be [provided](https://codemirror.net/6/docs/ref/#state.EditorStateConfig.extensions) when creating a state to attach various kinds of configuration and behavior information.
+   * They can either be built-in extension-providing objects,
+   * such as [state fields](https://codemirror.net/6/docs/ref/#state.StateField) or [facet providers](https://codemirror.net/6/docs/ref/#state.Facet.of),
+   * or objects with an extension in its `extension` property. Extensions can be nested in arrays arbitrarily deep—they will be flattened when processed.
+   */
+  extensions?: Extension[]
+  /**
+   * If the view is going to be mounted in a shadow root or document other than the one held by the global variable document (the default), you should pass it here.
+   * Originally from the [config of EditorView](https://codemirror.net/6/docs/ref/#view.EditorView.constructor%5Econfig.root)
+   */
+  root?: ShadowRoot | Document
+  /**
+   * Create a state from its JSON representation serialized with [toJSON](https://codemirror.net/docs/ref/#state.EditorState.toJSON) function
+   */
+  initialState?: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    json: any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fields?: Record<string, StateField<any>>
+  }
+}
+
+export interface UseCodeMirrorProps extends NuxtCodeMirrorProps {
+  container?: HTMLDivElement | null
+  viewRef: Ref<EditorView | undefined>
+  stateRef: Ref<EditorState | undefined>
+  containerRef: Ref<HTMLDivElement | null>
+}
+
+export interface Statistics {
+  /** total length of the document */
+  length: number
+  /** Get the number of lines in the editor. */
+  lineCount: number
+  /** Get the currently line description around the given position. */
+  line: Line
+  /** Get the proper [line-break](https://codemirror.net/docs/ref/#state.EditorState^lineSeparator) string for this state. */
+  lineBreak: string
+  /** Returns true when the editor is [configured](https://codemirror.net/6/docs/ref/#state.EditorState^readOnly) to be read-only. */
+  readOnly: boolean
+  /** The size (in columns) of a tab in the document, determined by the [`tabSize`](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize) facet. */
+  tabSize: number
+  /** Cursor Position */
+  selection: EditorSelection
+  /** Make sure the selection only has one range. */
+  selectionAsSingle: SelectionRange
+  /** Retrieves a list of all current selections. */
+  ranges: readonly SelectionRange[]
+  /** Get the currently selected code. */
+  selectionCode: string
+  /**
+   * The length of the given array should be the same as the number of active selections.
+   * Replaces the content of the selections with the strings in the array.
+   */
+  selections: string[]
+  /** Return true if any text is selected. */
+  selectedText: boolean
+}
+
+export interface CodeMirrorRef {
+  container: HTMLDivElement | null
+  view: EditorView | undefined
+  state: EditorState | undefined
+  editor: HTMLDivElement | null
+}

package/dist/runtime/utils/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ViewUpdate } from '@codemirror/view';
+import type { Statistics } from '../types/nuxt-codemirror.js';
+export declare const getStatistics: (view: ViewUpdate) => Statistics;

package/dist/runtime/utils/utils.js

@@ -0,0 +1,16 @@
+export const getStatistics = (view) => {
+  return {
+    line: view.state.doc.lineAt(view.state.selection.main.from),
+    lineCount: view.state.doc.lines,
+    lineBreak: view.state.lineBreak,
+    length: view.state.doc.length,
+    readOnly: view.state.readOnly,
+    tabSize: view.state.tabSize,
+    selection: view.state.selection,
+    selectionAsSingle: view.state.selection.asSingle().main,
+    ranges: view.state.selection.ranges,
+    selectionCode: view.state.sliceDoc(view.state.selection.main.from, view.state.selection.main.to),
+    selections: view.state.selection.ranges.map((r) => view.state.sliceDoc(r.from, r.to)),
+    selectedText: view.state.selection.ranges.some((r) => !r.empty)
+  };
+};

package/dist/types.d.mts

@@ -0,0 +1 @@
+export { type ModuleOptions, default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1 @@
+export { type ModuleOptions, default } from './module'

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "nuxt-codemirror",
+  "version": "0.0.1",
+  "description": "Nuxt codemirror module",
+  "repository": "https://github.com/ThimoDEV/nuxt-codemirror",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@codemirror/commands": "^6.6.0",
+    "@codemirror/lang-javascript": "^6.2.2",
+    "@codemirror/state": "6.4.1",
+    "@codemirror/theme-one-dark": "^6.1.1",
+    "@codemirror/view": "6.28.1",
+    "@nuxt/kit": "^3.12.4",
+    "@uiw/codemirror-extensions-basic-setup": "^4.23.0"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^1.3.9",
+    "@nuxt/eslint-config": "^0.3.13",
+    "@nuxt/module-builder": "^0.8.1",
+    "@nuxt/schema": "^3.12.4",
+    "@nuxt/test-utils": "^3.13.1",
+    "@types/node": "^20.14.11",
+    "changelogen": "^0.5.5",
+    "eslint": "^9.7.0",
+    "nuxt": "^3.12.4",
+    "typescript": "latest",
+    "vitest": "^2.0.3",
+    "vue-tsc": "^2.0.26"
+  }
+}