@cocoar/vue-script-editor 1.9.0-script-editor.4

package/LICENSE

@@ -0,0 +1,201 @@
+										Apache License
+								Version 2.0, January 2004
+							http://www.apache.org/licenses/
+
+	TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+	1. Definitions.
+
+		"License" shall mean the terms and conditions for use, reproduction,
+		and distribution as defined by Sections 1 through 9 of this document.
+
+		"Licensor" shall mean the copyright owner or entity authorized by
+		the copyright owner that is granting the License.
+
+		"Legal Entity" shall mean the union of the acting entity and all
+		other entities that control, are controlled by, or are under common
+		control with that entity. For the purposes of this definition,
+		"control" means (i) the power, direct or indirect, to cause the
+		direction or management of such entity, whether by contract or
+		otherwise, or (ii) ownership of fifty percent (50%) or more of the
+		outstanding shares, or (iii) beneficial ownership of such entity.
+
+		"You" (or "Your") shall mean an individual or Legal Entity
+		exercising permissions granted by this License.
+
+		"Source" form shall mean the preferred form for making modifications,
+		including but not limited to software source code, documentation
+		source, and configuration files.
+
+		"Object" form shall mean any form resulting from mechanical
+		transformation or translation of a Source form, including but
+		not limited to compiled object code, generated documentation,
+		and conversions to other media types.
+
+		"Work" shall mean the work of authorship, whether in Source or
+		Object form, made available under the License, as indicated by a
+		copyright notice that is included in or attached to the work
+		(an example is provided in the Appendix below).
+
+		"Derivative Works" shall mean any work, whether in Source or Object
+		form, that is based on (or derived from) the Work and for which the
+		editorial revisions, annotations, elaborations, or other modifications
+		represent, as a whole, an original work of authorship. For the purposes
+		of this License, Derivative Works shall not include works that remain
+		separable from, or merely link (or bind by name) to the interfaces of,
+		the Work and Derivative Works thereof.
+
+		"Contribution" shall mean any work of authorship, including
+		the original version of the Work and any modifications or additions
+		to that Work or Derivative Works thereof, that is intentionally
+		submitted to Licensor for inclusion in the Work by the copyright owner
+		or by an individual or Legal Entity authorized to submit on behalf of
+		the copyright owner. For the purposes of this definition, "submitted"
+		means any form of electronic, verbal, or written communication sent
+		to the Licensor or its representatives, including but not limited to
+		communication on electronic mailing lists, source code control systems,
+		and issue tracking systems that are managed by, or on behalf of, the
+		Licensor for the purpose of discussing and improving the Work, but
+		excluding communication that is conspicuously marked or otherwise
+		designated in writing by the copyright owner as "Not a Contribution."
+
+		"Contributor" shall mean Licensor and any individual or Legal Entity
+		on behalf of whom a Contribution has been received by Licensor and
+		subsequently incorporated within the Work.
+
+	2. Grant of Copyright License. Subject to the terms and conditions of
+		this License, each Contributor hereby grants to You a perpetual,
+		worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+		copyright license to reproduce, prepare Derivative Works of,
+		publicly display, publicly perform, sublicense, and distribute the
+		Work and such Derivative Works in Source or Object form.
+
+	3. Grant of Patent License. Subject to the terms and conditions of
+		this License, each Contributor hereby grants to You a perpetual,
+		worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+		(except as stated in this section) patent license to make, have made,
+		use, offer to sell, sell, import, and otherwise transfer the Work,
+		where such license applies only to those patent claims licensable
+		by such Contributor that are necessarily infringed by their
+		Contribution(s) alone or by combination of their Contribution(s)
+		with the Work to which such Contribution(s) was submitted. If You
+		institute patent litigation against any entity (including a
+		cross-claim or counterclaim in a lawsuit) alleging that the Work
+		or a Contribution incorporated within the Work constitutes direct
+		or contributory patent infringement, then any patent licenses
+		granted to You under this License for that Work shall terminate
+		as of the date such litigation is filed.
+
+	4. Redistribution. You may reproduce and distribute copies of the
+		Work or Derivative Works thereof in any medium, with or without
+		modifications, and in Source or Object form, provided that You
+		meet the following conditions:
+
+		(a) You must give any other recipients of the Work or
+			Derivative Works a copy of this License; and
+
+		(b) You must cause any modified files to carry prominent notices
+			stating that You changed the files; and
+
+		(c) You must retain, in the Source form of any Derivative Works
+			that You distribute, all copyright, patent, trademark, and
+			attribution notices from the Source form of the Work,
+			excluding those notices that do not pertain to any part of
+			the Derivative Works; and
+
+		(d) If the Work includes a "NOTICE" text file as part of its
+			distribution, then any Derivative Works that You distribute must
+			include a readable copy of the attribution notices contained
+			within such NOTICE file, excluding those notices that do not
+			pertain to any part of the Derivative Works, in at least one
+			of the following places: within a NOTICE text file distributed
+			as part of the Derivative Works; within the Source form or
+			documentation, if provided along with the Derivative Works; or,
+			within a display generated by the Derivative Works, if and
+			wherever such third-party notices normally appear. The contents
+			of the NOTICE file are for informational purposes only and
+			do not modify the License. You may add Your own attribution
+			notices within Derivative Works that You distribute, alongside
+			or as an addendum to the NOTICE text from the Work, provided
+			that such additional attribution notices cannot be construed
+			as modifying the License.
+
+		You may add Your own copyright statement to Your modifications and
+		may provide additional or different license terms and conditions
+		for use, reproduction, or distribution of Your modifications, or
+		for any such Derivative Works as a whole, provided Your use,
+		reproduction, and distribution of the Work otherwise complies with
+		the conditions stated in this License.
+
+	5. Submission of Contributions. Unless You explicitly state otherwise,
+		any Contribution intentionally submitted for inclusion in the Work
+		by You to the Licensor shall be under the terms and conditions of
+		this License, without any additional terms or conditions.
+		Notwithstanding the above, nothing herein shall supersede or modify
+		the terms of any separate license agreement you may have executed
+		with Licensor regarding such Contributions.
+
+	6. Trademarks. This License does not grant permission to use the trade
+		names, trademarks, service marks, or product names of the Licensor,
+		except as required for reasonable and customary use in describing the
+		origin of the Work and reproducing the content of the NOTICE file.
+
+	7. Disclaimer of Warranty. Unless required by applicable law or
+		agreed to in writing, Licensor provides the Work (and each
+		Contributor provides its Contributions) on an "AS IS" BASIS,
+		WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+		implied, including, without limitation, any warranties or conditions
+		of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+		PARTICULAR PURPOSE. You are solely responsible for determining the
+		appropriateness of using or redistributing the Work and assume any
+		risks associated with Your exercise of permissions under this License.
+
+	8. Limitation of Liability. In no event and under no legal theory,
+		whether in tort (including negligence), contract, or otherwise,
+		unless required by applicable law (such as deliberate and grossly
+		negligent acts) or agreed to in writing, shall any Contributor be
+		liable to You for damages, including any direct, indirect, special,
+		incidental, or consequential damages of any character arising as a
+		result of this License or out of the use or inability to use the
+		Work (including but not limited to damages for loss of goodwill,
+		work stoppage, computer failure or malfunction, or any and all
+		other commercial damages or losses), even if such Contributor
+		has been advised of the possibility of such damages.
+
+	9. Accepting Warranty or Additional Liability. While redistributing
+		the Work or Derivative Works thereof, You may choose to offer,
+		and charge a fee for, acceptance of support, warranty, indemnity,
+		or other liability obligations and/or rights consistent with this
+		License. However, in accepting such obligations, You may act only
+		on Your own behalf and on Your sole responsibility, not on behalf
+		of any other Contributor, and only if You agree to indemnify,
+		defend, and hold each Contributor harmless for any liability
+		incurred by, or claims asserted against, such Contributor by reason
+		of your accepting any such warranty or additional liability.
+
+	END OF TERMS AND CONDITIONS
+
+	APPENDIX: How to apply the Apache License to your work.
+
+		To apply the Apache License to your work, attach the following
+		boilerplate notice, with the fields enclosed by brackets "[]"
+		replaced with your own identifying information. (Don't include
+		the brackets!)  The text should be enclosed in the appropriate
+		comment syntax for the file format. We also recommend that a
+		file or class name and description of purpose be included on the
+		same "printed page" as the copyright notice for easier
+		identification within third-party archives.
+
+	Copyright [yyyy] [name of copyright owner]
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.

package/README.md

@@ -0,0 +1,278 @@
+# @cocoar/vue-script-editor
+
+Monaco-based script editor for Vue 3 with Cocoar Design System theming and **locked-line protection** for templates where signatures stay fixed and users fill in bodies.
+
+Initial scope: **TypeScript and JavaScript** only, with support for user-supplied type definitions (`extraLibs`).
+
+## Install
+
+```bash
+pnpm add @cocoar/vue-script-editor monaco-editor
+```
+
+`monaco-editor` is a peer dependency — consumers install and configure it themselves (this
+keeps the library bundle small and avoids double-bundling Monaco's ~5 MB of language services).
+
+## Worker setup
+
+Monaco needs its language services to run in Web Workers. You register them by assigning a
+getter to `self.MonacoEnvironment` **before any editor mounts**. Pick the pattern that
+matches your app's shape.
+
+### SPA (client-only, Vite)
+
+The common case — a single-page app that runs only in the browser. Register workers once at
+application entry:
+
+```ts
+// src/main.ts
+import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
+import TsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
+import JsonWorker from 'monaco-editor/esm/vs/language/json/json.worker?worker';
+
+self.MonacoEnvironment = {
+  getWorker(_workerId, label) {
+    if (label === 'typescript' || label === 'javascript') return new TsWorker();
+    if (label === 'json') return new JsonWorker();
+    return new EditorWorker();
+  },
+};
+```
+
+Drop the `JsonWorker` entries if you don't use JSON mode.
+
+### SSR / static-generation (VitePress, Nuxt, Astro)
+
+Monaco touches `window`, `document`, and the DOM — it cannot run during server-side
+rendering. Defer both the worker registration AND the editor import to `onMounted`, and
+guard with `<ClientOnly>` in your template:
+
+```vue
+<template>
+  <ClientOnly>
+    <component :is="Editor" v-if="Editor" v-model="code" />
+  </ClientOnly>
+</template>
+
+<script setup lang="ts">
+import { onMounted, ref, shallowRef, type Component } from 'vue';
+
+const Editor = shallowRef<Component | null>(null);
+const code = ref('// ...');
+
+onMounted(async () => {
+  const [mod, editorWorkerMod, tsWorkerMod, jsonWorkerMod] = await Promise.all([
+    import('@cocoar/vue-script-editor'),
+    import('monaco-editor/esm/vs/editor/editor.worker?worker'),
+    import('monaco-editor/esm/vs/language/typescript/ts.worker?worker'),
+    import('monaco-editor/esm/vs/language/json/json.worker?worker'),
+  ]);
+  self.MonacoEnvironment = {
+    getWorker(_workerId, label) {
+      if (label === 'typescript' || label === 'javascript') return new tsWorkerMod.default();
+      if (label === 'json') return new jsonWorkerMod.default();
+      return new editorWorkerMod.default();
+    },
+  };
+  Editor.value = mod.CoarScriptEditor;
+});
+</script>
+```
+
+`<ClientOnly>` is registered globally by VitePress and Nuxt. In a plain Vite SPA you don't
+need it — the SPA pattern above is simpler. In Astro use `client:only="vue"` on the component.
+
+### Other bundlers
+
+`monaco-editor`'s [official docs](https://github.com/microsoft/monaco-editor/tree/main/docs)
+cover Webpack, esbuild, Rollup, and plain CDN setups. The same `self.MonacoEnvironment.getWorker`
+contract applies — only the worker import syntax changes.
+
+## Basic usage
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue';
+import { CoarScriptEditor } from '@cocoar/vue-script-editor';
+
+const code = ref(`function greet(name: string) {\n  return \`Hello, \${name}\`;\n}\n`);
+</script>
+
+<template>
+  <CoarScriptEditor v-model="code" language="typescript" />
+</template>
+```
+
+## Constrained mode — `// @locked` lines
+
+Any line of the source that contains `// @locked` is **protected**: users cannot edit,
+merge, or delete it. Everything else is freely editable — including the file top, so
+TypeScript's Auto-Import quickfix works as in any normal `.ts` file.
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue';
+import { CoarScriptEditor, type CoarScriptEditorRejectEvent } from '@cocoar/vue-script-editor';
+
+const code = ref(`function describeOrder(order: Order): string { // @locked
+  return \`Order \${order.id}\`;
+} // @locked
+`);
+
+function onReject(event: CoarScriptEditorRejectEvent) {
+  // Reject reason is 'edit-overlaps-locked-line'. Surface a toast, shake, etc.
+  console.log('Edit rejected on line', event.range?.startLineNumber);
+}
+</script>
+
+<template>
+  <CoarScriptEditor v-model="code" language="typescript" @reject="onReject" />
+</template>
+```
+
+The `v-model` string **includes** the `// @locked` markers, so it round-trips through
+persistence unchanged — save and reload the exact same value.
+
+### Authoring mode
+
+Template authors need to edit the protected parts too. Pass `:authoring="true"` to suspend
+enforcement — locked lines become editable, markers render at full size with a warm accent
+colour, and the author can add or remove markers. Toggle back to `false` and enforcement
+resumes with whatever markers are currently in the text.
+
+```vue
+<CoarScriptEditor v-model="code" :authoring="isAuthor" />
+```
+
+### Custom type definitions (`extraLibs`)
+
+Inject `.d.ts` contents so user code can reference your domain types with full IntelliSense:
+
+```ts
+import type { CoarScriptEditorExtraLib } from '@cocoar/vue-script-editor';
+
+const extraLibs: CoarScriptEditorExtraLib[] = [
+  {
+    content: `declare interface AppContext { user: { id: string; name: string } };`,
+    // IMPORTANT: must start with `file:///` — Monaco's TypeScript service keys on path
+    // and silently ignores non-file URIs. A dev-mode console.warn flags this in dev.
+    filePath: 'file:///types/app-context.d.ts',
+  },
+];
+```
+
+### Pure helpers (no editor mount required)
+
+For server-side validation, submit-gating, or tests:
+
+```ts
+import {
+  hasLockedMarkers,
+  getEditableSegments,
+  isEverySegmentNonEmpty,
+  validateSource,
+  countLockedLines,
+} from '@cocoar/vue-script-editor';
+
+if (isEverySegmentNonEmpty(code)) submit(code);
+
+const v = validateSource(code);
+// v.ok, v.lockedLineCount, v.segmentCount, v.warnings: string[]
+```
+
+See the full docs page for the deeper helpers (`scanLockedLines`, `computeProtectedRanges`,
+`editIsProtected`, `snapOffsetAwayFromLocked`).
+
+## Props
+
+| Prop           | Type                                      | Default        | Description                                                                |
+| -------------- | ----------------------------------------- | -------------- | -------------------------------------------------------------------------- |
+| `modelValue`   | `string`                                  | `''`           | Editor content (use with `v-model`). `// @locked` lines protected.          |
+| `authoring`    | `boolean`                                 | `false`        | Authoring mode — suspends enforcement for template authors.                 |
+| `language`     | `'typescript' \| 'javascript' \| 'json'`  | `'typescript'` | Language mode.                                                             |
+| `readonly`     | `boolean`                                 | `false`        | Viewer mode — selection / copy still work.                                  |
+| `disabled`     | `boolean`                                 | `false`        | Non-interactive form state. Picked up from `CoarFormField`.                 |
+| `error`        | `boolean`                                 | `false`        | Error state — red border. Auto-picked up from `CoarFormField`.              |
+| `placeholder`  | `string`                                  | `''`           | Placeholder shown when empty and not focused.                              |
+| `required`     | `boolean`                                 | `false`        | Sets `aria-required="true"`.                                               |
+| `autofocus`    | `boolean`                                 | `false`        | Focus the editor after mount.                                              |
+| `id`           | `string`                                  | `''`           | HTML id (auto-generated if omitted; `CoarFormField.id` wins).               |
+| `name`         | `string`                                  | `''`           | Informational `data-name` (the editor is not a native form control).        |
+| `height`       | `string \| number`                        | `undefined`    | CSS string (`"160px"`, `"40vh"`) or pixels as number.                       |
+| `variant`      | `'editor' \| 'inline'`                    | `'editor'`     | UI preset: full chrome vs compact form-field look.                         |
+| `scriptMode`   | `boolean`                                 | `false`        | Suppress TS/JS diagnostics for script-body code. **Global side-effect**.    |
+| `preamble`     | `string`                                  | `''`           | Hidden + locked per-editor type context (not in `modelValue`).              |
+| `minimap`      | `boolean`                                 | `false`        | Show the Monaco minimap gutter.                                            |
+| `theme`        | `'auto' \| 'light' \| 'dark'`             | `'auto'`       | `auto` follows `.dark-mode` class and `prefers-color-scheme`.               |
+| `extraLibs`    | `CoarScriptEditorExtraLib[]`              | `[]`           | TypeScript declarations for IntelliSense.                                  |
+
+## Events
+
+| Event               | Payload                        | Description                                                                       |
+| ------------------- | ------------------------------ | --------------------------------------------------------------------------------- |
+| `update:modelValue` | `string`                       | Full editor text. Markers stay; preamble is stripped before emit.                 |
+| `reject`            | `CoarScriptEditorRejectEvent`  | Emitted when an edit was rolled back by the constrained guards.                    |
+| `focused`           | `void`                         | Editor widget gained focus (including suggestion popups).                          |
+| `blurred`           | `void`                         | Editor widget lost focus — use for form-touched state.                             |
+
+```ts
+interface CoarScriptEditorRejectEvent {
+  reason: 'edit-overlaps-locked-line';
+  range?: { startLineNumber: number; endLineNumber: number };
+}
+```
+
+## Exposed methods
+
+The component exposes `focus()` as a convenience, plus `getEditor()` and `getModel()` for access
+to the raw Monaco instance when you need APIs beyond the declarative props (markers, custom
+commands, folding, etc.):
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue';
+import { CoarScriptEditor } from '@cocoar/vue-script-editor';
+
+const editorRef = ref<InstanceType<typeof CoarScriptEditor> | null>(null);
+
+function focusEditor() {
+  editorRef.value?.focus();
+}
+</script>
+
+<template>
+  <CoarScriptEditor ref="editorRef" v-model="code" />
+</template>
+```
+
+## Forms
+
+`CoarScriptEditor` integrates with `CoarFormField` the same way `CoarTextInput` does — label,
+error state, `aria-describedby`, required marker, and disabled state all wire up automatically:
+
+```vue
+<CoarFormField label="Handler script" :error="scriptError" required>
+  <CoarScriptEditor
+    v-model="form.script"
+    variant="inline"
+    height="180px"
+    placeholder="// return query.filter(...)"
+    script-mode
+    preamble="declare const query: TodoQuery;"
+    :extra-libs="[{ filePath: 'file:///types/query.d.ts', content: queryTypes }]"
+  />
+</CoarFormField>
+```
+
+- **`preamble`** — hidden + locked type-context lines, per-editor scope. Emitted `modelValue`
+  is the user portion only.
+- **`script-mode`** — suppresses diagnostics for top-level `return`/`await`/`export`. Global
+  side-effect across all TS/JS editors.
+- **`variant="inline"`** — compact form-field chrome: no line numbers, no gutter, tight padding.
+- **`height`** — CSS string or pixels. The editor fills its parent if omitted.
+
+## Full documentation
+
+See the [Cocoar UI Vue docs](https://docs.cocoar.dev/cocoar-ui-vue/components/script-editor)
+for the complete guide, including styling, `@reject` payload details, a live playground,
+and the full list of pure helpers.

package/dist/CoarScriptEditor.vue.d.ts

@@ -0,0 +1,122 @@
+import { CoarScriptEditorLanguage, CoarScriptEditorVariant } from './composables/useMonacoEditor';
+import { CoarScriptEditorExtraLib } from './composables/useExtraLibs';
+import { CoarScriptEditorTheme } from './theme';
+export type CoarScriptEditorRejectReason = 'edit-overlaps-locked-line';
+/**
+ * Payload emitted by `@reject` when the guard rolls back an illegal edit. The shape is an
+ * object (not a bare string) so additional context can be added later without a breaking
+ * change — new fields stay optional.
+ */
+export interface CoarScriptEditorRejectEvent {
+    reason: CoarScriptEditorRejectReason;
+    /** 1-based line range of the edit that got rejected, if available. */
+    range?: {
+        startLineNumber: number;
+        endLineNumber: number;
+    };
+}
+export interface CoarScriptEditorProps {
+    /**
+     * Editor source. Any line containing `// @locked` (anywhere in the line) is protected
+     * from edits — including against being merged with its neighbours. Everything else is
+     * freely editable. The markers stay in the text, so the emitted value round-trips.
+     */
+    modelValue?: string;
+    /**
+     * Authoring mode. When true, lock enforcement is suspended so template authors can
+     * modify locked lines, add new `// @locked` lines, or remove existing markers. Markers
+     * render at full size with an accent colour so it's visually obvious that enforcement
+     * is off.
+     */
+    authoring?: boolean;
+    language?: CoarScriptEditorLanguage;
+    /** Read-only mode — user cannot edit but cursor, selection, and copy still work. */
+    readonly?: boolean;
+    /** Disabled state — non-interactive, dimmed, tab-skipped. Auto-picked up from CoarFormField. */
+    disabled?: boolean;
+    /** Error state — red border. Auto-picked up from CoarFormField.error. */
+    error?: boolean;
+    /** Placeholder text shown when the editor is empty and not focused. */
+    placeholder?: string;
+    /** Marks the field as required (sets aria-required; no enforcement). */
+    required?: boolean;
+    /** Autofocus on mount. */
+    autofocus?: boolean;
+    /** HTML id attribute. Auto-generated if omitted; CoarFormField's id takes precedence. */
+    id?: string;
+    /** HTML name attribute (informational — editor is not a native form control). */
+    name?: string;
+    /** Explicit height. Accepts CSS string (`"160px"`, `"40%"`) or number (pixels). */
+    height?: string | number;
+    /**
+     * UI preset.
+     *  - `'editor'` (default): full IDE chrome — line numbers, gutter, minimap-ready
+     *  - `'inline'`: compact form-field look — no line numbers, no gutter, tight padding
+     */
+    variant?: CoarScriptEditorVariant;
+    /**
+     * When true, suppresses diagnostic codes that flag "script body" constructs in TS/JS
+     * (top-level return/await/export, implicit any, etc). **Global side-effect** — affects
+     * all TS/JS editors on the page. No-op for JSON.
+     */
+    scriptMode?: boolean;
+    /**
+     * Hidden + locked prefix providing per-editor type context, e.g.
+     * `"declare const query: TodoQuery;"`. Rendered invisibly above the user script, so
+     * IntelliSense resolves against its declarations while the user can't see or edit it.
+     * Does not round-trip through `modelValue`.
+     */
+    preamble?: string;
+    minimap?: boolean;
+    theme?: CoarScriptEditorTheme;
+    /** TypeScript declaration files made available for autocomplete and type checking. */
+    extraLibs?: CoarScriptEditorExtraLib[];
+    /**
+     * Override the DOM node Monaco uses for overflow widgets (IntelliSense popup, hover,
+     * parameter hints). Set this when the editor is mounted inside a custom modal or overlay
+     * and you want the widgets in that modal's stacking context.
+     *
+     * For the Cocoar dialog (`useDialog().open(...)`) this is auto-detected — pass `null` to
+     * fall back to Monaco's default body-level container.
+     */
+    overflowWidgetsDomNode?: HTMLElement | null;
+}
+declare const _default: import('vue').DefineComponent<CoarScriptEditorProps, {
+    getEditor: () => import("monaco-editor").editor.IStandaloneCodeEditor | null;
+    getModel: () => import("monaco-editor").editor.ITextModel | null;
+    focus: () => void | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    reject: (event: CoarScriptEditorRejectEvent) => any;
+    focused: () => any;
+    blurred: () => any;
+}, string, import('vue').PublicProps, Readonly<CoarScriptEditorProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onReject?: ((event: CoarScriptEditorRejectEvent) => any) | undefined;
+    onFocused?: (() => any) | undefined;
+    onBlurred?: (() => any) | undefined;
+}>, {
+    overflowWidgetsDomNode: HTMLElement | null;
+    modelValue: string;
+    authoring: boolean;
+    language: CoarScriptEditorLanguage;
+    readonly: boolean;
+    disabled: boolean;
+    error: boolean;
+    placeholder: string;
+    required: boolean;
+    autofocus: boolean;
+    id: string;
+    name: string;
+    height: string | number;
+    variant: CoarScriptEditorVariant;
+    scriptMode: boolean;
+    preamble: string;
+    minimap: boolean;
+    theme: CoarScriptEditorTheme;
+    extraLibs: CoarScriptEditorExtraLib[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    host: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=CoarScriptEditor.vue.d.ts.map

package/dist/CoarScriptEditor.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoarScriptEditor.vue.d.ts","sourceRoot":"","sources":["../src/CoarScriptEditor.vue"],"names":[],"mappings":"AAuUA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAgB,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAGzF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD,MAAM,MAAM,4BAA4B,GAAG,2BAA2B,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,4BAA4B,CAAC;IACrC,sEAAsE;IACtE,KAAK,CAAC,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACpC,oFAAoF;IACpF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gGAAgG;IAChG,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yFAAyF;IACzF,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB;;;;OAIG;IACH,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,sFAAsF;IACtF,SAAS,CAAC,EAAE,wBAAwB,EAAE,CAAC;IACvC;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC7C;;;;;;;;;;;;;;;;4BAD0B,WAAW,GAAG,IAAI;gBA1D9B,MAAM;eAOP,OAAO;cACR,wBAAwB;cAExB,OAAO;cAEP,OAAO;WAEV,OAAO;iBAED,MAAM;cAET,OAAO;eAEN,OAAO;QAEd,MAAM;UAEJ,MAAM;YAEJ,MAAM,GAAG,MAAM;aAMd,uBAAuB;gBAMpB,OAAO;cAOT,MAAM;aACP,OAAO;WACT,qBAAqB;eAEjB,wBAAwB,EAAE;;;;AAoNxC,wBAWG"}

package/dist/composables/useConstrainedRegions.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { ChangeGuardRejectEvent } from '../constrained/ChangeGuard';
+import type * as monaco from 'monaco-editor';
+export interface UseConstrainedRegionsOptions {
+    editor: Readonly<Ref<monaco.editor.IStandaloneCodeEditor | null>>;
+    value: () => string;
+    /** When true, guards observe but do not reject. Markers stay visible. */
+    authoring: () => boolean;
+    onReject?: (event: ChangeGuardRejectEvent) => void;
+}
+/**
+ * Attaches change + cursor guards when the source contains locked-line markers, and draws
+ * decorations for each locked line (whole-line background tint + shrunk marker text).
+ * Tears itself down when no markers are present.
+ */
+export declare function useConstrainedRegions(options: UseConstrainedRegionsOptions): void;
+//# sourceMappingURL=useConstrainedRegions.d.ts.map

package/dist/composables/useConstrainedRegions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConstrainedRegions.d.ts","sourceRoot":"","sources":["../../src/composables/useConstrainedRegions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,EAA0B,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AACvD,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAC;AAQpC,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC,CAAC;IAClE,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,yEAAyE;IACzE,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;CACpD;AAOD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,CA2IjF"}

package/dist/composables/useExtraLibs.d.ts

@@ -0,0 +1,20 @@
+import { CoarScriptEditorLanguage } from './useMonacoEditor';
+export interface CoarScriptEditorExtraLib {
+    /** TypeScript declaration source (`.d.ts` contents). */
+    content: string;
+    /**
+     * Virtual file path the declarations live under. **Must start with `file:///`** —
+     * Monaco's TypeScript language service keys entries on the path and silently ignores
+     * non-`file://` URIs, so a bare `'types/foo.d.ts'` will compile without error but
+     * produce no IntelliSense.
+     *
+     * Examples: `'file:///types/order.d.ts'`, `'file:///node_modules/foo/index.d.ts'`.
+     */
+    filePath: string;
+}
+export interface UseExtraLibsOptions {
+    language: () => CoarScriptEditorLanguage;
+    libs: () => readonly CoarScriptEditorExtraLib[];
+}
+export declare function useExtraLibs(options: UseExtraLibsOptions): void;
+//# sourceMappingURL=useExtraLibs.d.ts.map

package/dist/composables/useExtraLibs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtraLibs.d.ts","sourceRoot":"","sources":["../../src/composables/useExtraLibs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE,MAAM,WAAW,wBAAwB;IACvC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,wBAAwB,CAAC;IACzC,IAAI,EAAE,MAAM,SAAS,wBAAwB,EAAE,CAAC;CACjD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA4D/D"}

package/dist/composables/useFormFieldContext.d.ts

@@ -0,0 +1,17 @@
+import { ComputedRef } from 'vue';
+/**
+ * Contract mirror of `@cocoar/vue-ui`'s `FormFieldProvided`. Duplicated here (rather than
+ * imported) so `@cocoar/vue-script-editor` doesn't have to pull `@cocoar/vue-ui` as a
+ * package dependency. The key is shared via `Symbol.for('coar:form-field')` — see
+ * `packages/ui/src/components/form-field/constants.ts` for the source of truth.
+ *
+ * When `CoarFormField`'s public shape changes, update both places.
+ */
+export interface FormFieldContext {
+    inputId: ComputedRef<string>;
+    messageId: ComputedRef<string>;
+    hasError: ComputedRef<boolean>;
+    disabled: ComputedRef<boolean>;
+}
+export declare function useFormFieldContext(): FormFieldContext | undefined;
+//# sourceMappingURL=useFormFieldContext.d.ts.map