@scalar/api-client 2.32.0 → 2.34.0

package/dist/v2/features/collection/components/Editor/helpers/json-pointer-links.js

@@ -0,0 +1,72 @@
+import * as c from "monaco-editor";
+import { parseJsonPointerPath as m } from "./json-pointer-path.js";
+const d = "scalar-json-pointer", g = (r, o) => {
+  if (r[o] !== '"')
+    return !1;
+  let t = 0;
+  for (let e = o - 1; e >= 0 && r[e] === "\\"; e--)
+    t++;
+  return t % 2 === 0;
+}, k = (r, o) => {
+  let t = -1;
+  for (let n = o; n >= 0; n--)
+    if (g(r, n)) {
+      t = n;
+      break;
+    }
+  if (t === -1)
+    return null;
+  let e = -1;
+  for (let n = Math.max(t + 1, o); n < r.length; n++)
+    if (g(r, n)) {
+      e = n;
+      break;
+    }
+  return e === -1 || e <= t ? null : { left: t, right: e };
+}, b = (r) => {
+  c.languages.registerLinkProvider("json", {
+    provideLinks(e) {
+      const n = [], l = e.getLineCount();
+      for (let s = 1; s <= l; s++) {
+        const a = e.getLineContent(s);
+        let u = 0;
+        for (; ; ) {
+          const f = a.indexOf("#/", u);
+          if (f === -1)
+            break;
+          const i = k(a, f);
+          if (!i) {
+            u = f + 2;
+            continue;
+          }
+          const p = a.slice(i.left + 1, i.right);
+          if (!m(p)) {
+            u = i.right + 1;
+            continue;
+          }
+          const h = new c.Range(s, i.left + 2, s, i.right + 1);
+          n.push({
+            range: h,
+            url: c.Uri.parse(`${d}:${encodeURIComponent(p)}`),
+            tooltip: "Follow link"
+          }), u = i.right + 1;
+        }
+      }
+      return { links: n };
+    }
+  });
+  const o = c.editor.registerLinkOpener({
+    open(e) {
+      if (e.scheme !== d)
+        return !1;
+      const n = (e.path || "").replace(/^\//, ""), l = decodeURIComponent(n);
+      return l ? Promise.resolve(r(l)).then(() => !0) : !1;
+    }
+  });
+  return { linkOpener: o, dispose: () => {
+    o.dispose();
+  } };
+};
+export {
+  b as ensureJsonPointerLinkSupport
+};

package/dist/v2/features/collection/components/Editor/helpers/json-pointer-path.d.ts

@@ -0,0 +1,7 @@
+import type { JsonPath } from './json-ast.js';
+/**
+ * Parses a JSON Pointer (RFC 6901) and returns a "JSON path" compatible with this editor.
+ * Supports raw pointers ("/paths/...") and URI fragments ("#/paths/...").
+ */
+export declare const parseJsonPointerPath: (pointer: string) => JsonPath | null;
+//# sourceMappingURL=json-pointer-path.d.ts.map

package/dist/v2/features/collection/components/Editor/helpers/json-pointer-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-pointer-path.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/helpers/json-pointer-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AA+B1C;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,KAAG,QAAQ,GAAG,IAOjE,CAAA"}

package/dist/v2/features/collection/components/Editor/helpers/json-pointer-path.js

@@ -0,0 +1,20 @@
+const i = (e) => e.replace(/~1/g, "/").replace(/~0/g, "~"), c = (e) => {
+  const t = e.trim();
+  if (t.startsWith("/"))
+    return t;
+  if (t.startsWith("#")) {
+    const s = t.slice(1);
+    return s.startsWith("/") ? s : null;
+  }
+  const r = t.indexOf("#");
+  if (r === -1)
+    return null;
+  const n = t.slice(r + 1);
+  return n.startsWith("/") ? n : null;
+}, o = (e) => {
+  const t = c(e);
+  return t ? t.split("/").slice(1).map(i) : null;
+};
+export {
+  o as parseJsonPointerPath
+};

package/dist/v2/features/collection/components/Editor/helpers/load-css-variables.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extracts CSS custom properties (variables) from a given CSS string
+ * for .light-mode and .dark-mode selectors and returns an object
+ * with 'light' and 'dark' keys containing the filtered variables.
+ * Only variables matching hex color values (#RRGGBB or #RRGGBBAA) are accepted.
+ *
+ * @param css - The CSS string to parse.
+ * @returns An object with `light` and `dark` properties containing the extracted CSS variables.
+ */
+export declare const loadCssVariables: (css: string) => Promise<{
+    light: any;
+    dark: any;
+}>;
+//# sourceMappingURL=load-css-variables.d.ts.map

package/dist/v2/features/collection/components/Editor/helpers/load-css-variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-css-variables.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/helpers/load-css-variables.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAU,KAAK,MAAM;WAIU,GAAG;UAAQ,GAAG;EA2CzE,CAAA"}

package/dist/v2/features/collection/components/Editor/helpers/load-css-variables.js

@@ -0,0 +1,21 @@
+import { z as n } from "zod";
+const f = async (a) => {
+  const i = new CSSStyleSheet();
+  return await i.replace(a), Array.from(i.cssRules).reduce(
+    (e, r) => {
+      if (!(r instanceof CSSStyleRule))
+        return e;
+      const l = Object.values(r.style).reduce((t, s) => {
+        if (!s.startsWith("--"))
+          return t;
+        const o = n.string().regex(/^(?:#(?:[0-9A-F]{6}|[0-9A-F]{8}))$/i).safeParse(r.style.getPropertyValue(s).toUpperCase().trim());
+        return o.error || (t[s] = o.data), t;
+      }, {});
+      return r.selectorText.includes(".light-mode") && (e.light = { ...e.light, ...l }), r.selectorText.includes(".dark-mode") && (e.dark = { ...e.dark, ...l }), e;
+    },
+    { light: {}, dark: {} }
+  );
+};
+export {
+  f as loadCssVariables
+};

package/dist/v2/features/collection/components/Editor/helpers/parse-editor-object.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses the editor value string in either JSON or YAML format.
+ * Returns the parsed object if valid and an object, otherwise returns null.
+ *
+ * @param value - The input string to parse.
+ * @param language - The language of the input string, either 'json' or 'yaml'.
+ * @returns The parsed object if it's valid, or null.
+ */
+export declare const parseEditorObject: (value: string, language: "json" | "yaml") => Record<string, unknown> | null;
+//# sourceMappingURL=parse-editor-object.d.ts.map

package/dist/v2/features/collection/components/Editor/helpers/parse-editor-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-editor-object.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/helpers/parse-editor-object.ts"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,EAAE,UAAU,MAAM,GAAG,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAOtG,CAAA"}

package/dist/v2/features/collection/components/Editor/helpers/parse-editor-object.js

@@ -0,0 +1,21 @@
+import { isObject as n } from "@scalar/helpers/object/is-object";
+import { parse as s } from "yaml";
+const a = (r) => {
+  try {
+    return JSON.parse(r);
+  } catch {
+    return null;
+  }
+}, o = (r) => {
+  try {
+    return s(r);
+  } catch {
+    return null;
+  }
+}, l = (r, e) => {
+  const t = e === "yaml" ? o(r) : a(r);
+  return n(t) ? t : null;
+};
+export {
+  l as parseEditorObject
+};

package/dist/v2/features/collection/components/Editor/helpers/stringify-document.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stringifies a JavaScript object/document into a formatted string.
+ * Uses YAML format if language is 'yaml', otherwise uses JSON.
+ *
+ * @param document - The JavaScript object to stringify
+ * @param language - Output language, expected to be either 'json' or 'yaml'
+ * @returns The stringified document in the specified language
+ */
+export declare const stringifyDocument: (document: unknown, language: "json" | "yaml") => string;
+//# sourceMappingURL=stringify-document.d.ts.map

package/dist/v2/features/collection/components/Editor/helpers/stringify-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify-document.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/helpers/stringify-document.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,OAAO,EAAE,UAAU,MAAM,GAAG,MAAM,KAAG,MAMhF,CAAA"}

package/dist/v2/features/collection/components/Editor/helpers/stringify-document.js

@@ -0,0 +1,5 @@
+import { stringify as n } from "yaml";
+const f = (r, i) => i === "yaml" ? n(r, { indent: 2 }) : JSON.stringify(r, null, 2);
+export {
+  f as stringifyDocument
+};

package/dist/v2/features/collection/components/Editor/helpers/yaml.worker.d.ts

@@ -0,0 +1,2 @@
+import 'monaco-yaml/yaml.worker.js';
+//# sourceMappingURL=yaml.worker.d.ts.map

package/dist/v2/features/collection/components/Editor/helpers/yaml.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.worker.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/helpers/yaml.worker.ts"],"names":[],"mappings":"AAAA,OAAO,4BAA4B,CAAA"}

package/dist/v2/features/collection/components/Editor/helpers/yaml.worker.js

@@ -0,0 +1,11 @@
+function r(e) {
+  return new Worker(
+    "/assets/yaml.worker-CcQnAKCg.js",
+    {
+      name: e?.name
+    }
+  );
+}
+export {
+  r as default
+};

package/dist/v2/features/collection/components/Editor/hooks/use-editor-markers.d.ts

@@ -0,0 +1,152 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { type MaybeRefOrGetter } from 'vue';
+export declare const useEditorMarkers: (editorRef: MaybeRefOrGetter<monaco.editor.IStandaloneCodeEditor | undefined>) => {
+    markers: import("vue").Ref<{
+        owner: string;
+        resource: {
+            readonly scheme: string;
+            readonly authority: string;
+            readonly path: string;
+            readonly query: string;
+            readonly fragment: string;
+            readonly fsPath: string;
+            with: (change: {
+                scheme?: string;
+                authority?: string | null;
+                path?: string | null;
+                query?: string | null;
+                fragment?: string | null;
+            }) => monaco.Uri;
+            toString: (skipEncoding?: boolean) => string;
+            toJSON: () => monaco.UriComponents;
+        };
+        severity: monaco.MarkerSeverity;
+        code?: string | {
+            value: string;
+            target: {
+                readonly scheme: string;
+                readonly authority: string;
+                readonly path: string;
+                readonly query: string;
+                readonly fragment: string;
+                readonly fsPath: string;
+                with: (change: {
+                    scheme?: string;
+                    authority?: string | null;
+                    path?: string | null;
+                    query?: string | null;
+                    fragment?: string | null;
+                }) => monaco.Uri;
+                toString: (skipEncoding?: boolean) => string;
+                toJSON: () => monaco.UriComponents;
+            };
+        } | undefined;
+        message: string;
+        source?: string | undefined;
+        startLineNumber: number;
+        startColumn: number;
+        endLineNumber: number;
+        endColumn: number;
+        modelVersionId?: number | undefined;
+        relatedInformation?: {
+            resource: {
+                readonly scheme: string;
+                readonly authority: string;
+                readonly path: string;
+                readonly query: string;
+                readonly fragment: string;
+                readonly fsPath: string;
+                with: (change: {
+                    scheme?: string;
+                    authority?: string | null;
+                    path?: string | null;
+                    query?: string | null;
+                    fragment?: string | null;
+                }) => monaco.Uri;
+                toString: (skipEncoding?: boolean) => string;
+                toJSON: () => monaco.UriComponents;
+            };
+            message: string;
+            startLineNumber: number;
+            startColumn: number;
+            endLineNumber: number;
+            endColumn: number;
+        }[] | undefined;
+        tags?: monaco.MarkerTag[] | undefined;
+        origin?: string | undefined | undefined;
+    }[], monaco.editor.IMarker[] | {
+        owner: string;
+        resource: {
+            readonly scheme: string;
+            readonly authority: string;
+            readonly path: string;
+            readonly query: string;
+            readonly fragment: string;
+            readonly fsPath: string;
+            with: (change: {
+                scheme?: string;
+                authority?: string | null;
+                path?: string | null;
+                query?: string | null;
+                fragment?: string | null;
+            }) => monaco.Uri;
+            toString: (skipEncoding?: boolean) => string;
+            toJSON: () => monaco.UriComponents;
+        };
+        severity: monaco.MarkerSeverity;
+        code?: string | {
+            value: string;
+            target: {
+                readonly scheme: string;
+                readonly authority: string;
+                readonly path: string;
+                readonly query: string;
+                readonly fragment: string;
+                readonly fsPath: string;
+                with: (change: {
+                    scheme?: string;
+                    authority?: string | null;
+                    path?: string | null;
+                    query?: string | null;
+                    fragment?: string | null;
+                }) => monaco.Uri;
+                toString: (skipEncoding?: boolean) => string;
+                toJSON: () => monaco.UriComponents;
+            };
+        } | undefined;
+        message: string;
+        source?: string | undefined;
+        startLineNumber: number;
+        startColumn: number;
+        endLineNumber: number;
+        endColumn: number;
+        modelVersionId?: number | undefined;
+        relatedInformation?: {
+            resource: {
+                readonly scheme: string;
+                readonly authority: string;
+                readonly path: string;
+                readonly query: string;
+                readonly fragment: string;
+                readonly fsPath: string;
+                with: (change: {
+                    scheme?: string;
+                    authority?: string | null;
+                    path?: string | null;
+                    query?: string | null;
+                    fragment?: string | null;
+                }) => monaco.Uri;
+                toString: (skipEncoding?: boolean) => string;
+                toJSON: () => monaco.UriComponents;
+            };
+            message: string;
+            startLineNumber: number;
+            startColumn: number;
+            endLineNumber: number;
+            endColumn: number;
+        }[] | undefined;
+        tags?: monaco.MarkerTag[] | undefined;
+        origin?: string | undefined | undefined;
+    }[]>;
+};
+//# sourceMappingURL=use-editor-markers.d.ts.map

package/dist/v2/features/collection/components/Editor/hooks/use-editor-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-editor-markers.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/hooks/use-editor-markers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,2CAA2C,CAAA;AACnE,OAAO,EAAE,KAAK,gBAAgB,EAAmD,MAAM,KAAK,CAAA;AAE5F,eAAO,MAAM,gBAAgB,GAAI,WAAW,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,GAAG,SAAS,CAAC;;;;;;;;;;;sBAkD0iJ,CAAC;yBAA2B,CAAC;oBAA6B,CAAC;qBAA8B,CAAC;wBAAiC,CAAC;;;;;;;;;;;;;;;;0BAA5H,CAAC;6BAA2B,CAAC;wBAA6B,CAAC;yBAA8B,CAAC;4BAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;0BAA5H,CAAC;6BAA2B,CAAC;wBAA6B,CAAC;yBAA8B,CAAC;4BAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;sBAA5H,CAAC;yBAA2B,CAAC;oBAA6B,CAAC;qBAA8B,CAAC;wBAAiC,CAAC;;;;;;;;;;;;;;;;0BAA5H,CAAC;6BAA2B,CAAC;wBAA6B,CAAC;yBAA8B,CAAC;4BAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;0BAA5H,CAAC;6BAA2B,CAAC;wBAA6B,CAAC;yBAA8B,CAAC;4BAAiC,CAAC;;;;;;;;;;;;;;CADlxJ,CAAA"}

package/dist/v2/features/collection/components/Editor/hooks/use-editor-markers.js

@@ -0,0 +1,34 @@
+import * as a from "monaco-editor/esm/vs/editor/editor.api.js";
+import { ref as m, onMounted as l, onBeforeUnmount as M, watch as g, toValue as d } from "vue";
+const f = (o) => {
+  const e = m([]);
+  let s = null;
+  const i = [], t = () => {
+    const n = d(o)?.getModel()?.uri;
+    if (!n) {
+      e.value = [];
+      return;
+    }
+    e.value = a.editor.getModelMarkers({}).filter((c) => c.resource.toString() === n.toString());
+  }, r = () => {
+    i.push(setTimeout(t, 0), setTimeout(t, 80), setTimeout(t, 220));
+  };
+  return l(() => {
+    s = a.editor.onDidChangeMarkers(() => {
+      r();
+    }), r();
+  }), M(() => {
+    s?.dispose(), i.forEach((u) => clearTimeout(u));
+  }), g(
+    () => d(o)?.getModel()?.uri?.toString(),
+    () => {
+      r();
+    },
+    { immediate: !0 }
+  ), {
+    markers: e
+  };
+};
+export {
+  f as useEditorMarkers
+};

package/dist/v2/features/collection/components/Editor/hooks/use-editor-state.d.ts

@@ -0,0 +1,14 @@
+import type { MonacoEditorLanguage } from '../../../../../../v2/features/collection/components/Editor/hooks/use-editor.js';
+export declare const useEditorState: () => {
+    isAutoSaveEnabled: import("vue").Ref<boolean, boolean>;
+    isDirty: import("vue").Ref<boolean, boolean>;
+    editorLanguage: import("vue").Ref<MonacoEditorLanguage, MonacoEditorLanguage>;
+    isDiagnosticsPaneExpanded: import("vue").Ref<boolean, boolean>;
+    isEditorMaximized: import("vue").Ref<boolean, boolean>;
+    isYamlMode: import("vue").ComputedRef<boolean>;
+    editorBottomPadding: import("vue").ComputedRef<46 | 155>;
+    editorRootClass: import("vue").ComputedRef<"" | "fixed inset-0 z-50 h-screen w-screen border bg-b-1 p-3">;
+    getLanguageToggleClass: (isActive: boolean) => string;
+    toggleEditorMaximized: () => void;
+};
+//# sourceMappingURL=use-editor-state.d.ts.map

package/dist/v2/features/collection/components/Editor/hooks/use-editor-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-editor-state.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/hooks/use-editor-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAA;AAKvG,eAAO,MAAM,cAAc;;;;;;;;;uCAeiB,OAAO,KAAG,MAAM;iCAQxB,IAAI;CAgBvC,CAAA"}

package/dist/v2/features/collection/components/Editor/hooks/use-editor-state.js

@@ -0,0 +1,25 @@
+import { ref as e, computed as o } from "vue";
+const g = 46, u = 155, E = () => {
+  const n = e(!1), a = e(!1), s = e("json"), i = e(!1), t = e(!1), c = o(() => s.value === "yaml"), r = o(
+    () => i.value ? u : g
+  ), d = o(
+    () => t.value ? "fixed inset-0 z-50 h-screen w-screen border bg-b-1 p-3" : ""
+  );
+  return {
+    isAutoSaveEnabled: n,
+    isDirty: a,
+    editorLanguage: s,
+    isDiagnosticsPaneExpanded: i,
+    isEditorMaximized: t,
+    isYamlMode: c,
+    editorBottomPadding: r,
+    editorRootClass: d,
+    getLanguageToggleClass: (l) => `rounded-none px-2 py-1 text-[11px] leading-4 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-c-accent/30 focus-visible:ring-offset-1 focus-visible:ring-offset-b-1 first:rounded-md last:rounded-md ${l ? "bg-b-2 text-c-1 hover:bg-b-2" : "text-c-2 hover:bg-b-2/60 hover:text-c-1"}`,
+    toggleEditorMaximized: () => {
+      t.value = !t.value;
+    }
+  };
+};
+export {
+  E as useEditorState
+};

package/dist/v2/features/collection/components/Editor/hooks/use-editor.d.ts

@@ -0,0 +1,39 @@
+import * as monaco from 'monaco-editor';
+import 'monaco-editor/esm/vs/language/json/monaco.contribution';
+import 'monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution';
+import 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding';
+import 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css';
+import 'monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css';
+import { type MaybeRefOrGetter } from 'vue';
+import type { JsonPath } from '../../../../../../v2/features/collection/components/Editor/helpers/json-ast.js';
+type MonacoEditorAction = {
+    id: string;
+    label: string;
+    keybindings?: number[];
+    run: () => void | Promise<void>;
+};
+export type MonacoEditorLanguage = 'json' | 'yaml';
+export declare const useEditor: ({ element, value, onChange, actions, readOnly, isDarkMode, theme, language, }: {
+    element: HTMLElement;
+    value?: MaybeRefOrGetter<string>;
+    readOnly?: MaybeRefOrGetter<boolean>;
+    onChange?: (e: string) => void;
+    actions?: MonacoEditorAction[];
+    isDarkMode?: MaybeRefOrGetter<boolean>;
+    theme?: MaybeRefOrGetter<string>;
+    language?: MonacoEditorLanguage;
+}) => {
+    editor: monaco.editor.IStandaloneCodeEditor;
+    model: monaco.editor.ITextModel;
+    highlightPath: (path: JsonPath) => Promise<void>;
+    focusPath: (path: JsonPath) => Promise<void>;
+    formatDocument: () => Promise<void>;
+    getValue: () => string;
+    setValue: (nextValue: string, isProgrammaticUpdate?: boolean) => void;
+    hasTextFocus: () => boolean;
+    setLanguage: (nextLanguage: MonacoEditorLanguage) => void;
+    setCursorToMarker: (marker: monaco.editor.IMarker) => void;
+    dispose: () => void;
+};
+export {};
+//# sourceMappingURL=use-editor.d.ts.map

package/dist/v2/features/collection/components/Editor/hooks/use-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-editor.d.ts","sourceRoot":"","sources":["../../../../../../../src/v2/features/collection/components/Editor/hooks/use-editor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,wDAAwD,CAAA;AAC/D,OAAO,6DAA6D,CAAA;AACpE,OAAO,6DAA6D,CAAA;AACpE,OAAO,iEAAiE,CAAA;AACxE,OAAO,mEAAmE,CAAA;AAG1E,OAAO,EAAE,KAAK,gBAAgB,EAAkB,MAAM,KAAK,CAAA;AAO3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6DAA6D,CAAA;AAI3F,KAAK,kBAAkB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,GAAG,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,CAAA;AAMlD,eAAO,MAAM,SAAS,GAAI,+EASvB;IACD,OAAO,EAAE,WAAW,CAAA;IACpB,KAAK,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAChC,QAAQ,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACpC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC9B,UAAU,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACtC,KAAK,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAChC,QAAQ,CAAC,EAAE,oBAAoB,CAAA;CAChC;;;0BA2FoC,QAAQ;sBASZ,QAAQ,KAAG,OAAO,CAAC,IAAI,CAAC;0BAoFtB,OAAO,CAAC,IAAI,CAAC;oBAIzB,MAAM;0BAEE,MAAM,qCAAiC,IAAI;wBAQ/C,OAAO;gCAEG,oBAAoB,KAAG,IAAI;gCAI3B,MAAM,CAAC,MAAM,CAAC,OAAO,KAAG,IAAI;mBAO3C,IAAI;CAmBzB,CAAA"}

package/dist/v2/features/collection/components/Editor/hooks/use-editor.js

@@ -0,0 +1,153 @@
+import * as r from "monaco-editor";
+import "monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css";
+import "monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
+import { presets as E } from "@scalar/themes";
+import { toValue as a, watch as c } from "vue";
+import { applyScalarTheme as J } from "../helpers/apply-scalar-theme.js";
+import { configureLanguageSupport as R } from "../helpers/configure-language-support.js";
+import { ensureMonacoEnvironment as k } from "../helpers/ensure-monaco-environment.js";
+import { getJsonAstNodeFromPath as D } from "../helpers/get-json-ast-node-from-path.js";
+import { getYamlNodeRangeFromPath as j } from "../helpers/get-yaml-node-range-from-path.js";
+import { ensureJsonPointerLinkSupport as z } from "../helpers/json-pointer-links.js";
+import { parseJsonPointerPath as B } from "../helpers/json-pointer-path.js";
+const ot = ({
+  element: w,
+  value: f,
+  onChange: b,
+  actions: O,
+  readOnly: m = !1,
+  isDarkMode: x = !1,
+  theme: S = E.default.theme,
+  language: C = "json"
+}) => {
+  k();
+  const n = r.editor.createModel(a(f) ?? "", C);
+  R(n.uri.toString());
+  const o = r.editor.create(w, {
+    model: n,
+    automaticLayout: !0,
+    folding: !0,
+    showFoldingControls: "always",
+    glyphMargin: !0,
+    lineNumbers: "on",
+    minimap: { enabled: !1 },
+    overviewRulerLanes: 0,
+    readOnly: a(m),
+    scrollbar: {
+      useShadows: !1,
+      verticalScrollbarSize: 5
+    },
+    scrollBeyondLastLine: !1,
+    guides: {
+      indentation: !0
+    },
+    formatOnPaste: !0,
+    renderValidationDecorations: "on",
+    formatOnType: !0,
+    lineHeight: 20,
+    renderLineHighlight: "none",
+    fontFamily: "'JetBrains Mono', monospace"
+  });
+  o.updateOptions({ insertSpaces: !0, tabSize: 2 });
+  let d = [], u = 0;
+  O?.forEach((t) => {
+    o.addAction({
+      id: t.id,
+      label: t.label,
+      keybindings: t.keybindings,
+      run: async () => {
+        await t.run();
+      }
+    });
+  });
+  const g = (t, e) => {
+    const s = n.getPositionAt(t), i = Math.max(t, e - 1), F = n.getPositionAt(i), P = Math.max(1, s.lineNumber), M = Math.max(P, F.lineNumber);
+    return new r.Range(P, 1, M, n.getLineMaxColumn(M));
+  }, p = async (t) => {
+    if (n.getLanguageId() === "yaml")
+      return j(n.getValue(), t);
+    const e = await D(n, t);
+    return e ? { startOffset: e.offset, endOffset: e.offset + e.length } : null;
+  }, l = async (t) => {
+    await o.getAction(t)?.run();
+  }, h = ({ startOffset: t, endOffset: e }) => {
+    const s = g(t, e);
+    d = o.deltaDecorations(d, [
+      {
+        range: s,
+        options: {
+          isWholeLine: !0,
+          className: "json-focus-highlight"
+        }
+      }
+    ]);
+  }, T = async (t) => {
+    const e = await p(t);
+    e && h(e);
+  }, y = async (t) => {
+    const e = await p(t);
+    if (!e)
+      return;
+    const s = g(e.startOffset, e.endOffset);
+    await l("editor.foldAll"), o.setSelection(s), await l("editor.unfoldRecursively");
+    const i = n.getPositionAt(e.startOffset);
+    o.setPosition(i), o.revealPositionNearTop(i), h(e);
+  }, N = async (t) => {
+    const e = B(t);
+    e && await y(e);
+  }, { dispose: v } = z(N);
+  o.onDidChangeModelContent(() => {
+    if (u > 0) {
+      u -= 1;
+      return;
+    }
+    const t = o.getValue();
+    typeof t == "string" && b?.(t ?? "");
+  }), c(
+    () => a(f),
+    (t) => {
+      t && o.getValue() !== t && L(t, !0);
+    }
+  ), c(
+    [() => a(S), () => a(x)],
+    async ([t, e]) => {
+      await J(t, e);
+    },
+    {
+      immediate: !0
+    }
+  ), c(
+    () => a(m),
+    (t) => {
+      o?.updateOptions({ readOnly: t });
+    }
+  );
+  const A = async () => {
+    await l("editor.action.formatDocument");
+  }, V = () => o.getValue(), L = (t, e = !1) => {
+    e && (u += 1), o.setValue(t);
+  };
+  return {
+    editor: o,
+    model: n,
+    highlightPath: T,
+    focusPath: y,
+    formatDocument: A,
+    getValue: V,
+    setValue: L,
+    hasTextFocus: () => o.hasTextFocus(),
+    setLanguage: (t) => {
+      r.editor.setModelLanguage(n, t);
+    },
+    setCursorToMarker: (t) => {
+      const e = Math.min(Math.max(t.startLineNumber || 1, 1), n.getLineCount()), s = Math.min(Math.max(t.startColumn || 1, 1), n.getLineMaxColumn(e));
+      o.setPosition({ lineNumber: e, column: s });
+    },
+    dispose: () => {
+      o.dispose(), n.dispose(), v();
+    }
+  };
+};
+export {
+  ot as useEditor
+};

package/dist/v2/features/collection/components/Editor/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Editor } from './Editor.vue.js';
+//# sourceMappingURL=index.d.ts.map