@adecore/editor-react 0.42.0 → 0.44.0

package/dist/snippet-session.d.ts

@@ -1,6 +1,6 @@
 import { type Timers } from './timers.ts';
 import { type SnippetTransformJob } from './snippet-transform-protocol.ts';
-import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
+import type { EditorApplyEditsOptions, EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import type { SnippetField, SnippetStop } from './snippet.ts';
 export declare function positionInInsertion(start: EditorPosition, text: string, offset: number): EditorPosition;
@@ -34,7 +34,7 @@ export declare class SnippetFeature {
     beginInstances(insertions: readonly SnippetInsertion[], options?: {
         nested?: boolean;
     }): void;
-    applyEdits(changes: readonly EditorContentChange[], token: number, extras?: readonly EditorContentChange[]): boolean;
+    applyEdits(changes: readonly EditorContentChange[], token: number, extras?: readonly EditorContentChange[], options?: EditorApplyEditsOptions): boolean;
     end(): void;
     private closeChoices;
     private pop;

package/dist/snippet-session.js

@@ -251,17 +251,17 @@ export class SnippetFeature {
     this.visit(0);
   }
   /* Imports can touch a hull's edge; their affinity must differ from edits inside its active field. */
-  applyEdits(changes, token, extras = []) {
+  applyEdits(changes, token, extras = [], options) {
     const frame = this.frames.at(-1);
     const fits = frame !== undefined && changes.every(edit => extras.includes(edit) ? frame.instances.every(instance => comparePositions(edit.range.end, instance.hull.start) <= 0 || comparePositions(edit.range.start, instance.hull.end) >= 0) : frame.instances.some(instance => instance.selected.some(range => rangeHolds(range, edit.range.start) && rangeHolds(range, edit.range.end))));
     if (token !== this.generation || !fits) {
       this.end();
-      return this.language.editor.applyEdits(changes);
+      return this.language.editor.applyEdits(changes, options);
     }
     this.applying = true;
     this.extras = extras;
     try {
-      return this.language.editor.applyEdits(changes);
+      return this.language.editor.applyEdits(changes, options);
     } finally {
       this.applying = false;
       this.extras = [];

package/dist/snippet.d.ts

@@ -28,11 +28,17 @@ export interface ParsedSnippet {
     })[];
 }
 export type SnippetVariableResolver = (name: string) => string | undefined;
+export interface SnippetRenderOptions {
+    readonly indentVariables?: boolean;
+}
 export interface SnippetTemplate {
     readonly source: string;
-    render(resolve?: SnippetVariableResolver, variableTransforms?: readonly string[]): ParsedSnippet;
+    render(resolve?: SnippetVariableResolver, variableTransforms?: readonly string[], options?: SnippetRenderOptions): ParsedSnippet;
 }
 export declare const MAX_SNIPPET_TEXT = 100000;
 export declare function compileSnippet(source: string): SnippetTemplate;
 export declare function parseSnippet(snippet: string, resolve?: SnippetVariableResolver): ParsedSnippet;
 export declare function tabOrder(parsed: ParsedSnippet): SnippetStop[];
+export declare function snippetVariables(source: string): ReadonlySet<string>;
+export declare function checkSnippet(source: string): string | null;
+export declare function escapeSnippetText(text: string): string;

package/dist/snippet.js

@@ -168,6 +168,11 @@ class SnippetParser {
     return values;
   }
 }
+/* The lines of a value after its first, behind the whitespace the last line of `before` starts with; blank lines stay blank. */
+function indentLines(value, before) {
+  const prefix = /^[\t ]*/.exec(before.slice(before.lastIndexOf('\n') + 1))[0];
+  return prefix === '' ? value : value.replace(/(\r\n|\r|\n)(?=[^\r\n])/g, `$1${prefix}`);
+}
 function renderSnippet(nodes, variableTransforms) {
   const definitions = new Map();
   const collect = nodes => {
@@ -216,7 +221,8 @@ function renderSnippet(nodes, variableTransforms) {
       const order = occurrence++;
       if (node.kind === 'text') {
         const start = text.length;
-        const value = node.transform === undefined || variableTransforms === undefined ? node.text : variableTransforms[transforms.length];
+        const given = node.transform === undefined || variableTransforms === undefined ? node.text : variableTransforms[transforms.length];
+        const value = node.indent === true && typeof given === 'string' ? indentLines(given, text) : given;
         if (typeof value !== 'string') {
           throw new RangeError('The variable transform count does not match the snippet.');
         }
@@ -352,7 +358,7 @@ function variableIndices(nodes) {
     return [name, highest];
   }));
 }
-function resolveVariables(nodes, indices, resolve) {
+function resolveVariables(nodes, indices, resolve, indentVariables = false) {
   const unknown = new Map();
   const values = new Map();
   const valueOf = name => {
@@ -408,10 +414,16 @@ function resolveVariables(nodes, indices, resolve) {
             transform: node.transform
           }];
         }
-        return value !== undefined && value !== '' ? [{
-          kind: 'text',
-          text: value
-        }] : normalize(node.body ?? [], visiting, depth + 1);
+        if (value !== undefined && value !== '') {
+          return [{
+            kind: 'text',
+            text: value,
+            ...(indentVariables ? {
+              indent: true
+            } : {})
+          }];
+        }
+        return normalize(node.body ?? [], visiting, depth + 1);
       }
       if (node.kind === 'field') {
         return [{
@@ -464,7 +476,7 @@ export function compileSnippet(source) {
   }
   return {
     source,
-    render: (resolve, variableTransforms) => {
+    render: (resolve, variableTransforms, options) => {
       if (nodes === null) {
         return {
           text: source,
@@ -473,7 +485,7 @@ export function compileSnippet(source) {
         };
       }
       try {
-        return renderSnippet(resolveVariables(nodes, indices, resolve), variableTransforms);
+        return renderSnippet(resolveVariables(nodes, indices, resolve, options?.indentVariables === true), variableTransforms);
       } catch (error) {
         if (!(error instanceof SnippetLimitError)) {
           throw error;
@@ -518,4 +530,49 @@ export function tabOrder(parsed) {
     start: parsed.text.length,
     end: parsed.text.length
   }];
+}
+/* The names of the variables a snippet uses, the editable ones that are no built-in too. A source that does not parse names none. */
+export function snippetVariables(source) {
+  const names = new Set();
+  const scan = nodes => {
+    for (const node of nodes) {
+      if (node.kind === 'variable') {
+        names.add(node.name);
+      }
+      if (node.kind !== 'text' && node.body !== undefined) {
+        scan(node.body);
+      }
+    }
+  };
+  if (source.length > MAX_SNIPPET_TEXT) {
+    return names;
+  }
+  try {
+    scan(new SnippetParser(source).parse());
+  } catch {
+    return new Set();
+  }
+  return names;
+}
+/* Why a snippet cannot be used, in English for a host to show, or null: it does not parse, or it is over the limits an insertion keeps. */
+export function checkSnippet(source) {
+  if (source.length > MAX_SNIPPET_TEXT) {
+    return `The text is longer than ${MAX_SNIPPET_TEXT} characters.`;
+  }
+  try {
+    new SnippetParser(source).parse();
+  } catch (error) {
+    if (error instanceof MalformedSnippetError) {
+      return 'A transform in the text is not valid.';
+    }
+    if (error instanceof SnippetLimitError) {
+      return 'The text has too many parts or is nested too deeply.';
+    }
+    throw error;
+  }
+  return compileSnippet(source).render().limited === true ? 'The text expands to more than a snippet can hold.' : null;
+}
+/* Escapes `\`, `$` and `}`, so the text reads back as itself in a snippet. */
+export function escapeSnippetText(text) {
+  return text.replace(/[\\$}]/g, '\\$&');
 }

package/dist/surround-constructs.d.ts

@@ -0,0 +1,10 @@
+import type { CommentSyntax } from '@adecore/editor';
+import type { TemplateLanguage } from './templates.ts';
+export interface Construct {
+    readonly id: string;
+    readonly label: string;
+    readonly body: string;
+}
+export declare function statementConstructs(families: readonly TemplateLanguage[]): readonly Construct[];
+export declare function expressionConstructs(families: readonly TemplateLanguage[]): readonly Construct[];
+export declare function regionConstructs(syntax: CommentSyntax): readonly Construct[];

package/dist/surround-constructs.js

@@ -0,0 +1,100 @@
+import { escapeSnippetText } from './snippet.js';
+const SELECTED = '$TM_SELECTED_TEXT';
+function block(head, tail = '') {
+  return `${head} {\n\t${SELECTED}\n}${tail}`;
+}
+const JS_STATEMENTS = [{
+  id: 'if',
+  label: 'if',
+  body: block('if ($1)')
+}, {
+  id: 'ifElse',
+  label: 'if / else',
+  body: block('if ($1)', ' else {\n\t$2\n}')
+}, {
+  id: 'while',
+  label: 'while',
+  body: block('while ($1)')
+}, {
+  id: 'doWhile',
+  label: 'do / while',
+  body: `do {\n\t${SELECTED}\n} while ($1);`
+}, {
+  id: 'for',
+  label: 'for',
+  body: block('for (let ${1:i} = 0; $1 < $2; $1++)')
+}, {
+  id: 'tryCatch',
+  label: 'try / catch',
+  body: block('try', ' catch (${1:e}) {\n\t$0\n}')
+}, {
+  id: 'tryFinally',
+  label: 'try / finally',
+  body: block('try', ' finally {\n\t$0\n}')
+}, {
+  id: 'tryCatchFinally',
+  label: 'try / catch / finally',
+  body: block('try', ' catch (${1:e}) {\n\t$2\n} finally {\n\t$0\n}')
+}, {
+  id: 'braces',
+  label: '{ }',
+  body: `{\n\t${SELECTED}\n}`
+}, {
+  id: 'function',
+  label: 'function',
+  body: block('function ${1:name}()')
+}];
+const PHP_STATEMENTS = [JS_STATEMENTS[0], JS_STATEMENTS[1], JS_STATEMENTS[2], JS_STATEMENTS[3], {
+  id: 'for',
+  label: 'for',
+  body: block('for (\\$${1:i} = 0; \\$$1 < $2; \\$$1++)')
+}, {
+  id: 'foreach',
+  label: 'foreach',
+  body: block('foreach (\\$${1:array} as \\$${2:value})')
+}, {
+  id: 'tryCatch',
+  label: 'try / catch',
+  body: block('try', ' catch (${1:\\\\Exception} \\$${2:e}) {\n\t$0\n}')
+}, JS_STATEMENTS[6], JS_STATEMENTS[7], JS_STATEMENTS[9]];
+const EXPRESSIONS = [{
+  id: 'parentheses',
+  label: '(expr)',
+  body: `(${SELECTED})`
+}, {
+  id: 'not',
+  label: '!(expr)',
+  body: `!(${SELECTED})`
+}];
+/* The statement surrounders of the first of the families that has any; JavaScript and TypeScript share theirs. */
+export function statementConstructs(families) {
+  if (families.includes('javascript')) {
+    return JS_STATEMENTS;
+  }
+  return families.includes('php') ? PHP_STATEMENTS : [];
+}
+/* The surrounders of one expression, which JavaScript, TypeScript and PHP share. */
+export function expressionConstructs(families) {
+  return families.includes('javascript') || families.includes('php') ? EXPRESSIONS : [];
+}
+/*
+ * The two comment pairs that fold a region, written with the language's own comments: the line comment, or the block
+ * pair where there is none. There is no space after the marker, so the output reads `//region Description`.
+ */
+export function regionConstructs(syntax) {
+  const marker = syntax.line ?? syntax.block?.open;
+  if (marker === undefined) {
+    return [];
+  }
+  const start = escapeSnippetText(marker);
+  const end = syntax.line === null ? escapeSnippetText(syntax.block?.close ?? '') : '';
+  return [{
+    id: 'region',
+    label: 'region...endregion',
+    body: `${start}region \${1:Description}${end}\n${SELECTED}\n${start}endregion${end}`
+  }, {
+    id: 'editorFold',
+    label: '<editor-fold...>',
+    body: `${start}<editor-fold desc="\${1:Description}">${end}\n${SELECTED}\n${start}</editor-fold>${end}`
+  }];
+}

package/dist/surround.d.ts

@@ -0,0 +1,18 @@
+import type { EditorLanguage } from './editor-language.ts';
+export declare class SurroundFeature {
+    private readonly language;
+    constructor(language: EditorLanguage);
+    open(): boolean;
+    openTemplates(): boolean;
+    unwrap(): boolean;
+    private show;
+    private refuse;
+    private subjectOf;
+    private groupsOf;
+    private insert;
+    private indentUnit;
+    private previewOf;
+    private unwrapRows;
+    private applyUnwrap;
+    private unwrapPreview;
+}