nuxt-monaco-editor 1.3.1 → 1.3.2

package/dist/module.d.mts

@@ -11,4 +11,5 @@ interface ModuleOptions {
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-export { type ModuleOptions, type MonacoEditorLocale, _default as default };
+export { _default as default };
+export type { ModuleOptions, MonacoEditorLocale };

package/dist/module.json

@@ -4,9 +4,9 @@
   "compatibility": {
     "nuxt": ">=3.1.0"
   },
-  "version": "1.3.1",
+  "version": "1.3.2",
   "builder": {
-    "@nuxt/module-builder": "0.8.4",
-    "unbuild": "2.0.0"
+    "@nuxt/module-builder": "1.0.1",
+    "unbuild": "3.5.0"
   }
 }

package/dist/module.mjs

@@ -4,15 +4,6 @@ import { viteStaticCopy } from 'vite-plugin-static-copy';
 import fs from 'fs/promises';
 import { createRequire } from 'node:module';
 
-
-
-// -- Unbuild CommonJS Shims --
-import __cjs_url__ from 'url';
-import __cjs_path__ from 'path';
-import __cjs_mod__ from 'module';
-const __filename = __cjs_url__.fileURLToPath(import.meta.url);
-const __dirname = __cjs_path__.dirname(__filename);
-const require = __cjs_mod__.createRequire(import.meta.url);
 const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
 const { resolve } = createResolver(runtimeDir);
 const rewrittenMonacoFiles = /* @__PURE__ */ new Map();
@@ -22,7 +13,7 @@ const plugin = (options, nuxtOptions) => ({
   name: "vite-plugin-nuxt-monaco-editor",
   enforce: "pre",
   resolveId(src) {
-    if (src.includes("monaco-editor/esm/vs/") && src.endsWith(".js?worker")) {
+    if (/monaco-editor\/esm\/vs\/.*\.worker\.js/.test(src)) {
       return resolveModule(
         src.replace("?worker", "").replace("__skip_vite", "").replace("node_modules", "").replace(nuxtOptions.app.baseURL, "/").replace(/\/\/+/g, "/").replace(/^\//, "")
       );
@@ -78,6 +69,7 @@ const getDefaults = (nuxt) => {
     }
   };
 };
+const require = createRequire(import.meta.url);
 const module = defineNuxtModule({
   meta: {
     name: "nuxt-monaco-editor",

package/dist/runtime/MonacoDiffEditor.client.vue

@@ -4,117 +4,81 @@
   </div>
 </template>
 
-<script lang="ts" setup>
-import type * as Monaco from 'monaco-editor'
-import { onBeforeUnmount, ref, shallowRef, watch } from 'vue'
-import { defu } from 'defu'
-import { useMonaco } from './composables'
-
-interface Props {
-  /**
-   * Programming Language (Not a locale for UI);
-   * overrides `options.language`
-  */
-  lang?: string;
-  /**
-   * Options passed to the second argument of `monaco.editor.createDiffEditor`
-   */
-  options?: Monaco.editor.IStandaloneDiffEditorConstructionOptions;
-  /**
-   * The URI that identifies models
-   */
-  // eslint-disable-next-line vue/require-default-prop
-  originalModelUri?: Monaco.Uri;
-
-  /**
-   * The URI that identifies models
-   */
-  // eslint-disable-next-line vue/require-default-prop
-  modelUri?: Monaco.Uri;
-
-  original?: string;
-  modelValue?: string;
-}
-
-interface Emits {
-  (event: 'update:modelValue', value: string): void
-  (event: 'load', editor: Monaco.editor.IStandaloneDiffEditor): void
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  lang: () => 'plaintext',
-  options: () => ({}),
-  original: () => '',
-  modelValue: () => ''
-})
-const emit = defineEmits<Emits>()
-const isLoading = ref(true)
-
-const editorElement = shallowRef<HTMLDivElement>()
-const monaco = useMonaco()!
-
-let editor: Monaco.editor.IStandaloneDiffEditor
-let originalModel: Monaco.editor.ITextModel
-let modifiedModel: Monaco.editor.ITextModel
-
-const editorRef = shallowRef<Monaco.editor.IStandaloneDiffEditor>()
-const defaultOptions: Monaco.editor.IStandaloneEditorConstructionOptions = {
+<script setup>
+import { onBeforeUnmount, ref, shallowRef, watch } from "vue";
+import { defu } from "defu";
+import { useMonaco } from "./composables";
+const props = defineProps({
+  lang: { type: String, required: false, default: () => "plaintext" },
+  options: { type: null, required: false, default: () => ({}) },
+  originalModelUri: { type: null, required: false },
+  modelUri: { type: null, required: false },
+  original: { type: String, required: false, default: () => "" },
+  modelValue: { type: String, required: false, default: () => "" }
+});
+const emit = defineEmits(["update:modelValue", "load"]);
+const isLoading = ref(true);
+const editorElement = shallowRef();
+const monaco = useMonaco();
+let editor;
+let originalModel;
+let modifiedModel;
+const editorRef = shallowRef();
+const defaultOptions = {
   automaticLayout: true
-}
-
+};
 watch(() => [props.original, props.modelValue], () => {
   if (originalModel.getValue() !== props.original || modifiedModel.getValue() !== props.modelValue) {
-    originalModel.setValue(props.original)
-    modifiedModel.setValue(props.modelValue)
+    originalModel.setValue(props.original);
+    modifiedModel.setValue(props.modelValue);
   }
-})
-
+});
 watch(() => props.lang, () => {
-  const originalValue = originalModel?.getValue() || props.original
-  const modifiedValue = modifiedModel?.getValue() || props.modelValue
-  if (originalModel) { originalModel.dispose() }
-  if (modifiedModel) { modifiedModel.dispose() }
-  originalModel = monaco.editor.createModel(originalValue, props.lang, props.originalModelUri)
-  modifiedModel = monaco.editor.createModel(modifiedValue, props.lang, props.modelUri)
+  const originalValue = originalModel?.getValue() || props.original;
+  const modifiedValue = modifiedModel?.getValue() || props.modelValue;
+  if (originalModel) {
+    originalModel.dispose();
+  }
+  if (modifiedModel) {
+    modifiedModel.dispose();
+  }
+  originalModel = monaco.editor.createModel(originalValue, props.lang, props.originalModelUri);
+  modifiedModel = monaco.editor.createModel(modifiedValue, props.lang, props.modelUri);
   editor.setModel({
     original: originalModel,
     modified: modifiedModel
-  })
-})
-
+  });
+});
 watch(() => props.options, () => {
-  editor?.updateOptions(defu(props.options, defaultOptions))
-})
-
+  editor?.updateOptions(defu(props.options, defaultOptions));
+});
 defineExpose({
   /**
    * Monaco editor instance
    */
   $editor: editorRef
-})
-
+});
 watch(editorElement, (newValue, oldValue) => {
-  if (!editorElement.value || oldValue) { return }
-  editor = monaco.editor.createDiffEditor(editorElement.value!, defu(props.options, defaultOptions))
-  editorRef.value = editor
-  originalModel = monaco.editor.createModel(props.original, props.lang, props.originalModelUri)
-  modifiedModel = monaco.editor.createModel(props.modelValue, props.lang, props.modelUri)
+  if (!editorElement.value || oldValue) {
+    return;
+  }
+  editor = monaco.editor.createDiffEditor(editorElement.value, defu(props.options, defaultOptions));
+  editorRef.value = editor;
+  originalModel = monaco.editor.createModel(props.original, props.lang, props.originalModelUri);
+  modifiedModel = monaco.editor.createModel(props.modelValue, props.lang, props.modelUri);
   editor.setModel({
     original: originalModel,
     modified: modifiedModel
-  })
-
+  });
   editor.onDidUpdateDiff(() => {
-    emit('update:modelValue', editor.getModel()!.modified.getValue())
-  })
-
-  isLoading.value = false
-  emit('load', editor)
-})
-
+    emit("update:modelValue", editor.getModel().modified.getValue());
+  });
+  isLoading.value = false;
+  emit("load", editor);
+});
 onBeforeUnmount(() => {
-  editor?.dispose()
-  originalModel?.dispose()
-  modifiedModel?.dispose()
-})
+  editor?.dispose();
+  originalModel?.dispose();
+  modifiedModel?.dispose();
+});
 </script>

package/dist/runtime/MonacoDiffEditor.client.vue.d.ts

@@ -0,0 +1,50 @@
+import type * as Monaco from 'monaco-editor';
+interface Props {
+    /**
+     * Programming Language (Not a locale for UI);
+     * overrides `options.language`
+    */
+    lang?: string;
+    /**
+     * Options passed to the second argument of `monaco.editor.createDiffEditor`
+     */
+    options?: Monaco.editor.IStandaloneDiffEditorConstructionOptions;
+    /**
+     * The URI that identifies models
+     */
+    originalModelUri?: Monaco.Uri;
+    /**
+     * The URI that identifies models
+     */
+    modelUri?: Monaco.Uri;
+    original?: string;
+    modelValue?: string;
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {
+    /**
+     * Monaco editor instance
+     */
+    $editor: import("vue").ShallowRef<Monaco.editor.IStandaloneDiffEditor | undefined, Monaco.editor.IStandaloneDiffEditor | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    load: (editor: Monaco.editor.IStandaloneDiffEditor) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onLoad?: ((editor: Monaco.editor.IStandaloneDiffEditor) => any) | undefined;
+}>, {
+    lang: string;
+    options: Monaco.editor.IStandaloneDiffEditorConstructionOptions;
+    original: string;
+    modelValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/MonacoEditor.client.vue

@@ -4,96 +4,65 @@
   </div>
 </template>
 
-<script lang="ts" setup>
-import * as Monaco from 'monaco-editor'
-import { computed, ref, shallowRef, watch, onBeforeUnmount } from 'vue'
-import { defu } from 'defu'
-import { useMonaco } from './composables'
-
-interface Props {
-    /**
-     * Programming Language (Not a locale for UI);
-     * overrides `options.language`
-     */
-    lang?: string;
-    /**
-     * Options passed to the second argument of `monaco.editor.create`
-     */
-    options?: Monaco.editor.IStandaloneEditorConstructionOptions;
-    /**
-     * The URI that identifies models
-     */
-    // eslint-disable-next-line vue/require-default-prop
-    modelUri?: Monaco.Uri;
-
-    modelValue?: string;
-}
-
-interface Emits {
-    (event: 'update:modelValue', value: string): void
-    (event: 'load', editor: Monaco.editor.IStandaloneCodeEditor): void
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  lang: () => 'plaintext',
-  options: () => ({}),
-  modelValue: () => ''
-})
-
-const emit = defineEmits<Emits>()
-const isLoading = ref(true)
-const lang = computed(() => props.lang || props.options.language)
-const editorRef = shallowRef<Monaco.editor.IStandaloneCodeEditor>()
-const editorElement = ref<HTMLDivElement>()
-const monaco = useMonaco()!
-const defaultOptions: Monaco.editor.IStandaloneEditorConstructionOptions = {
+<script setup>
+import { computed, ref, shallowRef, watch, onBeforeUnmount } from "vue";
+import { defu } from "defu";
+import { useMonaco } from "./composables";
+const props = defineProps({
+  lang: { type: String, required: false, default: () => "plaintext" },
+  options: { type: null, required: false, default: () => ({}) },
+  modelUri: { type: null, required: false },
+  modelValue: { type: String, required: false, default: () => "" }
+});
+const emit = defineEmits(["update:modelValue", "load"]);
+const isLoading = ref(true);
+const lang = computed(() => props.lang || props.options.language);
+const editorRef = shallowRef();
+const editorElement = ref();
+const monaco = useMonaco();
+const defaultOptions = {
   automaticLayout: true
-}
-
-let editor: Monaco.editor.IStandaloneCodeEditor
-let model: Monaco.editor.ITextModel
-
+};
+let editor;
+let model;
 watch(() => props.modelValue, () => {
   if (editor?.getValue() !== props.modelValue) {
-    editor?.setValue(props.modelValue)
+    editor?.setValue(props.modelValue);
   }
-})
-
+});
 watch(() => [props.lang, props.modelUri], () => {
   if (model) {
-    model.dispose()
+    model.dispose();
   }
-  model = monaco.editor.createModel(props.modelValue, lang.value, props.modelUri)
-  editor?.setModel(model)
-})
-
+  model = monaco.editor.createModel(props.modelValue, lang.value, props.modelUri);
+  editor?.setModel(model);
+});
 watch(() => props.options, () => {
-  editor?.updateOptions(defu(props.options, defaultOptions))
-})
-
+  editor?.updateOptions(defu(props.options, defaultOptions));
+});
 watch(editorElement, (newValue, oldValue) => {
-  if (!editorElement.value || oldValue) { return }
-  editor = monaco.editor.create(editorElement.value!, defu(props.options, defaultOptions))
-  model = monaco.editor.createModel(props.modelValue, lang.value, props.modelUri)
-  editorRef.value = editor
-  editor.layout()
-  editor.setModel(model)
+  if (!editorElement.value || oldValue) {
+    return;
+  }
+  editor = monaco.editor.create(editorElement.value, defu(props.options, defaultOptions));
+  model = monaco.editor.createModel(props.modelValue, lang.value, props.modelUri);
+  editorRef.value = editor;
+  editor.layout();
+  editor.setModel(model);
   editor.onDidChangeModelContent(() => {
-    emit('update:modelValue', editor.getValue())
-  })
-  isLoading.value = false
-  emit('load', editor)
-})
-
+    emit("update:modelValue", editor.getValue());
+  });
+  isLoading.value = false;
+  emit("load", editor);
+});
 defineExpose({
   /**
      * Monaco editor instance
      */
   $editor: editorRef
-})
-
+});
 onBeforeUnmount(() => {
-  editor?.dispose()
-  model?.dispose()
-})
+  editor?.dispose();
+  model?.dispose();
+});
 </script>

package/dist/runtime/MonacoEditor.client.vue.d.ts

@@ -0,0 +1,44 @@
+import type * as Monaco from 'monaco-editor';
+interface Props {
+    /**
+     * Programming Language (Not a locale for UI);
+     * overrides `options.language`
+     */
+    lang?: string;
+    /**
+     * Options passed to the second argument of `monaco.editor.create`
+     */
+    options?: Monaco.editor.IStandaloneEditorConstructionOptions;
+    /**
+     * The URI that identifies models
+     */
+    modelUri?: Monaco.Uri;
+    modelValue?: string;
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {
+    /**
+       * Monaco editor instance
+       */
+    $editor: import("vue").ShallowRef<Monaco.editor.IStandaloneCodeEditor | undefined, Monaco.editor.IStandaloneCodeEditor | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    load: (editor: Monaco.editor.IStandaloneCodeEditor) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onLoad?: ((editor: Monaco.editor.IStandaloneCodeEditor) => any) | undefined;
+}>, {
+    lang: string;
+    options: Monaco.editor.IStandaloneEditorConstructionOptions;
+    modelValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/nls.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-unused-vars */
 import localeData from '__LOCALE_DATA_PATH__'
 
 export function _format (message, args) {

package/dist/runtime/plugin-dev.client.d.ts

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

package/dist/runtime/plugin-prod.client.d.ts

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

package/dist/types.d.mts

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

package/package.json

@@ -11,21 +11,19 @@
     "type": "git",
     "url": "https://github.com/e-chan1007/nuxt-monaco-editor.git"
   },
-  "version": "1.3.1",
+  "version": "1.3.2",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": {
       "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs",
-      "types": "./dist/types.d.ts"
+      "types": "./dist/types.d.mts"
     },
     "./dist/*": {
       "import": "./dist/*"
     }
   },
-  "main": "./dist/module.cjs",
-  "types": "./dist/types.d.ts",
+  "main": "./dist/module.mjs",
   "files": [
     "dist"
   ],
@@ -47,39 +45,43 @@
     "loc:build": "jiti scripts/build-loc.ts"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.13.2",
+    "@nuxt/kit": "^3.17.5",
     "defu": "^6.1.4",
-    "vite-plugin-static-copy": "^2.0.0"
+    "vite-plugin-static-copy": "^3.0.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.5.0",
-    "@commitlint/config-conventional": "^19.5.0",
-    "@nuxt/module-builder": "0.8.4",
-    "@nuxt/test-utils": "3.11.0",
-    "@nuxtjs/eslint-config-typescript": "^12.1.0",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@nuxt/eslint-config": "^1.4.1",
+    "@nuxt/module-builder": "1.0.1",
+    "@nuxt/test-utils": "3.19.1",
     "@vue/test-utils": "^2.4.6",
-    "eslint": "^8.57.1",
-    "execa": "^9.4.1",
-    "happy-dom": "^15.7.4",
-    "husky": "^9.1.6",
-    "jiti": "^2.3.3",
-    "monaco-editor": "^0.52.0",
-    "nuxt": "^3.13.2",
-    "nuxt-content-twoslash": "^0.1.1",
+    "eslint": "^9.29.0",
+    "execa": "^9.6.0",
+    "happy-dom": "^18.0.1",
+    "husky": "^9.1.7",
+    "jiti": "^2.4.2",
+    "monaco-editor": "^0.52.2",
+    "nuxt": "^3.17.5",
+    "nuxt-content-twoslash": "^0.1.2",
     "pinst": "^3.0.0",
-    "playwright": "^1.48.1",
-    "playwright-core": "^1.48.1",
+    "playwright": "^1.53.0",
+    "playwright-core": "^1.53.0",
     "remark-cli": "^12.0.1",
-    "remark-lint": "^10.0.0",
-    "remark-preset-lint-recommended": "^7.0.0",
-    "shadcn-docs-nuxt": "^0.6.4",
+    "remark-lint": "^10.0.1",
+    "remark-preset-lint-recommended": "^7.0.1",
+    "shadcn-docs-nuxt": "^1.0.3",
     "standard-version": "^9.5.0",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.3"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "vue-tsc": "^2.2.10"
   },
   "peerDependencies": {
     "monaco-editor": "*"
   },
+  "resolutions": {
+    "@unhead/vue": "^2"
+  },
   "remarkConfig": {
     "plugins": [
       "remark-preset-lint-recommended",

package/dist/module.cjs

@@ -1,5 +0,0 @@
-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.ts

@@ -1,14 +0,0 @@
-import * as _nuxt_schema from '@nuxt/schema';
-
-type MonacoEditorLocale = 'cs' | 'de' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'pl' | 'pt-br' | 'qps-ploc' | 'ru' | 'tr' | 'zh-hans' | 'zh-hant' | 'en';
-interface ModuleOptions {
-    locale?: MonacoEditorLocale;
-    removeSourceMaps?: boolean;
-    componentName?: {
-        codeEditor?: string;
-        diffEditor?: string;
-    };
-}
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
-
-export { type ModuleOptions, type MonacoEditorLocale, _default as default };

package/dist/types.d.ts

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