@likec4/language-server 1.1.1 → 1.2.1

package/dist/model/model-parser.js

@@ -1,410 +0,0 @@
-import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { AstUtils } from "langium";
-import { isTruthy } from "remeda";
-import stripIndent from "strip-indent";
-import {
-  ast,
-  checksFromDiagnostics,
-  cleanParsedModel,
-  ElementViewOps,
-  isFqnIndexedDocument,
-  parseAstOpacityProperty,
-  resolveRelationPoints,
-  streamModel,
-  toAutoLayout,
-  toElementStyle,
-  toRelationshipStyleExcludeDefaults
-} from "../ast.js";
-import { elementRef, getFqnElementRef } from "../elementRef.js";
-import { logError, logger, logWarnError } from "../logger.js";
-import { stringHash } from "../utils/index.js";
-const { getDocument } = AstUtils;
-function toSingleLine(str) {
-  return str ? removeIndent(str).split("\n").join(" ") : void 0;
-}
-function removeIndent(str) {
-  return str ? stripIndent(str).trim() : void 0;
-}
-export class LikeC4ModelParser {
-  constructor(services) {
-    this.services = services;
-    this.fqnIndex = services.likec4.FqnIndex;
-    logger.debug(`[ModelParser] Created`);
-  }
-  fqnIndex;
-  parse(doc) {
-    const docs = Array.isArray(doc) ? doc : [doc];
-    const result = [];
-    for (const doc2 of docs) {
-      if (!isFqnIndexedDocument(doc2)) {
-        logger.warn(`Not a FqnIndexedDocument: ${doc2.uri.toString(true)}`);
-        continue;
-      }
-      try {
-        result.push(this.parseLikeC4Document(doc2));
-      } catch (cause) {
-        logError(new InvalidModelError(`Error parsing document ${doc2.uri.toString()}`, { cause }));
-      }
-    }
-    return result;
-  }
-  parseLikeC4Document(_doc) {
-    const doc = cleanParsedModel(_doc);
-    this.parseSpecification(doc);
-    this.parseModel(doc);
-    this.parseViews(doc);
-    return doc;
-  }
-  parseSpecification(doc) {
-    const { isValid: isValid2 } = checksFromDiagnostics(doc);
-    const { parseResult, c4Specification } = doc;
-    const specifications = parseResult.value.specifications.filter(isValid2);
-    const element_specs = specifications.flatMap((s) => s.elements.filter(isValid2));
-    for (const { kind, style } of element_specs) {
-      try {
-        const kindName = kind.name;
-        c4Specification.kinds[kindName] = {
-          ...c4Specification.kinds[kindName],
-          ...toElementStyle(style?.props)
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-    const relations_specs = specifications.flatMap((s) => s.relationships.filter(isValid2));
-    for (const { kind, props } of relations_specs) {
-      try {
-        const kindName = kind.name;
-        c4Specification.relationships[kindName] = {
-          ...c4Specification.relationships[kindName],
-          ...toRelationshipStyleExcludeDefaults(props)
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-  }
-  parseModel(doc) {
-    for (const el of streamModel(doc)) {
-      if (ast.isElement(el)) {
-        try {
-          doc.c4Elements.push(this.parseElement(el));
-        } catch (e) {
-          logWarnError(e);
-        }
-        continue;
-      }
-      if (ast.isRelation(el)) {
-        try {
-          doc.c4Relations.push(this.parseRelation(el));
-        } catch (e) {
-          logWarnError(e);
-        }
-        continue;
-      }
-      nonexhaustive(el);
-    }
-  }
-  parseElement(astNode) {
-    const id = this.resolveFqn(astNode);
-    const kind = astNode.kind.$refText;
-    const tags = this.convertTags(astNode.body);
-    const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
-    const style = toElementStyle(stylePropsAst);
-    const astPath = this.getAstNodePath(astNode);
-    let [title, description, technology] = astNode.props ?? [];
-    const bodyProps = astNode.body?.props.filter(ast.isElementStringProperty) ?? [];
-    title = toSingleLine(title ?? bodyProps.find((p) => p.key === "title")?.value);
-    description = removeIndent(description ?? bodyProps.find((p) => p.key === "description")?.value);
-    technology = toSingleLine(technology ?? bodyProps.find((p) => p.key === "technology")?.value);
-    const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
-    return {
-      id,
-      kind,
-      astPath,
-      title: title ?? astNode.name,
-      ...tags && { tags },
-      ...links && isNonEmptyArray(links) && { links },
-      ...isTruthy(technology) && { technology },
-      ...isTruthy(description) && { description },
-      style
-    };
-  }
-  parseRelation(astNode) {
-    const coupling = resolveRelationPoints(astNode);
-    const target = this.resolveFqn(coupling.target);
-    const source = this.resolveFqn(coupling.source);
-    const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
-    const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
-    const kind = astNode.kind?.ref?.name;
-    const astPath = this.getAstNodePath(astNode);
-    const title = toSingleLine(
-      astNode.title ?? astNode.body?.props.find((p) => p.key === "title")?.value
-    ) ?? "";
-    const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
-    const id = stringHash(
-      astPath,
-      source,
-      target
-    );
-    return {
-      id,
-      astPath,
-      source,
-      target,
-      title,
-      ...kind && { kind },
-      ...tags && { tags },
-      ...isNonEmptyArray(links) && { links },
-      ...toRelationshipStyleExcludeDefaults(styleProp?.props)
-    };
-  }
-  parseViews(doc) {
-    const { isValid: isValid2 } = checksFromDiagnostics(doc);
-    const views = doc.parseResult.value.views.flatMap((v) => isValid2(v) ? v.views.filter(isValid2) : []);
-    for (const view of views) {
-      try {
-        const v = this.parseElementView(view, isValid2);
-        doc.c4Views.push(v);
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-  }
-  parseElementExpr(astNode) {
-    if (ast.isWildcardExpr(astNode)) {
-      return {
-        wildcard: true
-      };
-    }
-    if (ast.isElementKindExpr(astNode)) {
-      return {
-        elementKind: astNode.kind.$refText,
-        isEqual: astNode.isEqual
-      };
-    }
-    if (ast.isElementTagExpr(astNode)) {
-      let elementTag = astNode.tag.$refText;
-      if (elementTag.startsWith("#")) {
-        elementTag = elementTag.slice(1);
-      }
-      return {
-        elementTag,
-        isEqual: astNode.isEqual
-      };
-    }
-    if (ast.isExpandElementExpr(astNode)) {
-      const elementNode = elementRef(astNode.parent);
-      invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
-      const expanded = this.resolveFqn(elementNode);
-      return {
-        expanded
-      };
-    }
-    if (ast.isDescedantsExpr(astNode)) {
-      const elementNode = elementRef(astNode.parent);
-      invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
-      const element = this.resolveFqn(elementNode);
-      return {
-        element,
-        isDescedants: true
-      };
-    }
-    if (ast.isElementRef(astNode)) {
-      const elementNode = elementRef(astNode);
-      invariant(elementNode, "Element not found " + astNode.$cstNode?.text);
-      const element = this.resolveFqn(elementNode);
-      return {
-        element
-      };
-    }
-    nonexhaustive(astNode);
-  }
-  parseCustomElementExpr(astNode) {
-    let targetRef;
-    if (ast.isElementRef(astNode.target)) {
-      targetRef = astNode.target;
-    } else if (ast.isExpandElementExpr(astNode.target)) {
-      targetRef = astNode.target.parent;
-    } else {
-      invariant(false, "ElementRef expected as target of custom element");
-    }
-    const elementNode = elementRef(targetRef);
-    invariant(elementNode, "element not found: " + astNode.$cstNode?.text);
-    const element = this.resolveFqn(elementNode);
-    const props = astNode.body?.props ?? [];
-    return props.reduce(
-      (acc, prop) => {
-        if (ast.isNavigateToProperty(prop)) {
-          const viewId = prop.value.view.$refText;
-          if (isTruthy(viewId)) {
-            acc.custom.navigateTo = viewId;
-          }
-          return acc;
-        }
-        if (ast.isElementStringProperty(prop)) {
-          const value = prop.key === "description" ? removeIndent(prop.value) : toSingleLine(prop.value);
-          acc.custom[prop.key] = value.trim();
-          return acc;
-        }
-        if (ast.isIconProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isColorProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isShapeProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isBorderProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isOpacityProperty(prop)) {
-          acc.custom[prop.key] = parseAstOpacityProperty(prop);
-          return acc;
-        }
-        nonexhaustive(prop);
-      },
-      {
-        custom: {
-          element
-        }
-      }
-    );
-  }
-  parsePredicateExpr(astNode) {
-    if (ast.isRelationExpr(astNode)) {
-      return {
-        source: this.parseElementExpr(astNode.source),
-        target: this.parseElementExpr(astNode.target),
-        isBidirectional: astNode.isBidirectional
-      };
-    }
-    if (ast.isInOutExpr(astNode)) {
-      return {
-        inout: this.parseElementExpr(astNode.inout.to)
-      };
-    }
-    if (ast.isOutgoingExpr(astNode)) {
-      return {
-        outgoing: this.parseElementExpr(astNode.from)
-      };
-    }
-    if (ast.isIncomingExpr(astNode)) {
-      return {
-        incoming: this.parseElementExpr(astNode.to)
-      };
-    }
-    if (ast.isCustomElementExpr(astNode)) {
-      return this.parseCustomElementExpr(astNode);
-    }
-    if (ast.isElementExpr(astNode)) {
-      return this.parseElementExpr(astNode);
-    }
-    nonexhaustive(astNode);
-  }
-  parseViewRule(astRule, isValid2) {
-    if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
-      const exprs = astRule.expressions.flatMap((n) => {
-        try {
-          return isValid2(n) ? this.parsePredicateExpr(n) : [];
-        } catch (e) {
-          logWarnError(e);
-          return [];
-        }
-      });
-      return ast.isIncludePredicate(astRule) ? { include: exprs } : { exclude: exprs };
-    }
-    if (ast.isViewRuleStyle(astRule)) {
-      const styleProps = toElementStyle(astRule.styleprops);
-      return {
-        targets: astRule.targets.map((n) => this.parseElementExpr(n)),
-        style: {
-          ...styleProps
-        }
-      };
-    }
-    if (ast.isViewRuleAutoLayout(astRule)) {
-      return {
-        autoLayout: toAutoLayout(astRule.direction)
-      };
-    }
-    nonexhaustive(astRule);
-  }
-  parseElementView(astNode, isValid2) {
-    const body = astNode.body;
-    invariant(body, "ElementView body is not defined");
-    const astPath = this.getAstNodePath(astNode);
-    let viewOf = null;
-    if ("viewOf" in astNode) {
-      const viewOfEl = elementRef(astNode.viewOf);
-      const _viewOf = viewOfEl && this.resolveFqn(viewOfEl);
-      if (!_viewOf) {
-        logger.warn("viewOf is not resolved: " + astNode.$cstNode?.text);
-      } else {
-        viewOf = _viewOf;
-      }
-    }
-    let id = astNode.name;
-    if (!id) {
-      id = "view_" + stringHash(
-        getDocument(astNode).uri.toString(),
-        astPath,
-        viewOf ?? ""
-      );
-    }
-    const title = toSingleLine(body.props.find((p) => p.key === "title")?.value);
-    const description = removeIndent(body.props.find((p) => p.key === "description")?.value);
-    const tags = this.convertTags(body);
-    const links = body.props.filter(ast.isLinkProperty).map((p) => p.value);
-    const basic = {
-      id,
-      astPath,
-      ...viewOf && { viewOf },
-      ...title && { title },
-      ...description && { description },
-      ...tags && { tags },
-      ...isNonEmptyArray(links) && { links },
-      rules: body.rules.flatMap((n) => {
-        try {
-          return isValid2(n) ? this.parseViewRule(n, isValid2) : [];
-        } catch (e) {
-          logWarnError(e);
-          return [];
-        }
-      })
-    };
-    ElementViewOps.writeId(astNode, basic.id);
-    if ("extends" in astNode) {
-      const extendsView = astNode.extends.view.ref;
-      invariant(extendsView?.name, "view extends is not resolved: " + astNode.$cstNode?.text);
-      return {
-        ...basic,
-        extends: extendsView.name
-      };
-    }
-    return basic;
-  }
-  resolveFqn(node) {
-    if (ast.isExtendElement(node)) {
-      return getFqnElementRef(node.element);
-    }
-    const fqn = this.fqnIndex.getFqn(node);
-    invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
-    return fqn;
-  }
-  getAstNodePath(node) {
-    return this.services.workspace.AstNodeLocator.getAstNodePath(node);
-  }
-  convertTags(withTags) {
-    if (!withTags) {
-      return null;
-    }
-    const tags = withTags.tags?.value.flatMap(({ ref }) => ref ? ref.name : []);
-    return isNonEmptyArray(tags) ? tags : null;
-  }
-}

package/dist/model-change/ModelChanges.d.ts

@@ -1,15 +0,0 @@
-import { Location, TextEdit } from 'vscode-languageserver-protocol';
-import { type ParsedLikeC4LangiumDocument } from '../ast';
-import type { LikeC4Services } from '../module';
-import type { ChangeViewRequestParams } from '../protocol';
-export declare class LikeC4ModelChanges {
-    private services;
-    private locator;
-    constructor(services: LikeC4Services);
-    applyChange(changeView: ChangeViewRequestParams): Promise<Location | null>;
-    protected convertToTextEdit({ viewId, changes }: ChangeViewRequestParams): {
-        doc: ParsedLikeC4LangiumDocument;
-        edits: TextEdit[];
-    };
-}
-//# sourceMappingURL=ModelChanges.d.ts.map

package/dist/model-change/ModelChanges.js

@@ -1,100 +0,0 @@
-import { invariant, nonexhaustive } from "@likec4/core";
-import { Range } from "vscode-languageserver-protocol";
-import { changeElementStyle } from "./changeElementStyle.js";
-import { changeViewLayout } from "./changeViewLayout.js";
-function unionRangeOfAllEdits(edits) {
-  let start = Number.MAX_SAFE_INTEGER;
-  let end = Number.MIN_SAFE_INTEGER;
-  let startCharacter = Number.MAX_SAFE_INTEGER;
-  let endCharacter = Number.MIN_SAFE_INTEGER;
-  for (const { range } of edits) {
-    if (range.start.line <= start) {
-      if (start == range.start.line) {
-        startCharacter = Math.min(range.start.character, startCharacter);
-      } else {
-        start = range.start.line;
-        startCharacter = range.start.character;
-      }
-    }
-    if (end <= range.end.line) {
-      if (end == range.end.line) {
-        endCharacter = Math.max(range.end.character, endCharacter);
-      } else {
-        end = range.end.line;
-        endCharacter = range.end.character;
-      }
-    }
-  }
-  return Range.create(start, startCharacter, end, endCharacter);
-}
-export class LikeC4ModelChanges {
-  constructor(services) {
-    this.services = services;
-    this.locator = services.likec4.ModelLocator;
-  }
-  locator;
-  async applyChange(changeView) {
-    const lspConnection = this.services.shared.lsp.Connection;
-    invariant(lspConnection, "LSP Connection not available");
-    let result = null;
-    await this.services.shared.workspace.WorkspaceLock.write(async () => {
-      const { doc, edits } = this.convertToTextEdit(changeView);
-      const textDocument = {
-        uri: doc.textDocument.uri,
-        version: doc.textDocument.version
-      };
-      if (!edits.length) {
-        return;
-      }
-      const applyResult = await lspConnection.workspace.applyEdit({
-        label: `LikeC4 - change view ${changeView.viewId}`,
-        edit: {
-          changes: {
-            [textDocument.uri]: edits
-          }
-        }
-      });
-      if (!applyResult.applied) {
-        lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
-        return;
-      }
-      result = {
-        uri: textDocument.uri,
-        range: unionRangeOfAllEdits(edits)
-      };
-    });
-    return result;
-  }
-  convertToTextEdit({ viewId, changes }) {
-    const lookup = this.locator.locateViewAst(viewId);
-    if (!lookup) {
-      throw new Error(`View not found: ${viewId}`);
-    }
-    const edits = [];
-    for (const change of changes) {
-      switch (change.op) {
-        case "change-element-style": {
-          edits.push(...changeElementStyle(this.services, {
-            ...lookup,
-            targets: change.targets,
-            style: change.style
-          }));
-          break;
-        }
-        case "change-autolayout": {
-          edits.push(...changeViewLayout(this.services, {
-            ...lookup,
-            layout: change.layout
-          }));
-          break;
-        }
-        default:
-          nonexhaustive(change);
-      }
-    }
-    return {
-      doc: lookup.doc,
-      edits
-    };
-  }
-}

package/dist/model-change/changeElementStyle.d.ts

@@ -1,15 +0,0 @@
-import { type Fqn, type NonEmptyArray } from '@likec4/core';
-import { TextEdit } from 'vscode-languageserver-protocol';
-import { ast, type ParsedAstElementView, type ParsedLikeC4LangiumDocument } from '../ast';
-import type { LikeC4Services } from '../module';
-import type { ChangeView } from '../protocol';
-type ChangeElementStyleArg = {
-    view: ParsedAstElementView;
-    doc: ParsedLikeC4LangiumDocument;
-    viewAst: ast.ElementView;
-    targets: NonEmptyArray<Fqn>;
-    style: ChangeView.ChangeElementStyle['style'];
-};
-export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style }: ChangeElementStyleArg): TextEdit[];
-export {};
-//# sourceMappingURL=changeElementStyle.d.ts.map

package/dist/model-change/changeElementStyle.js

@@ -1,141 +0,0 @@
-import { invariant, isAncestor, nonNullable } from "@likec4/core";
-import { GrammarUtils } from "langium";
-import { entries, findLast, isNumber, last } from "remeda";
-import { TextEdit } from "vscode-languageserver-protocol";
-import { ast } from "../ast.js";
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
-const asViewStyleRule = (target, style, indent = 0) => {
-  const indentStr = indent > 0 ? " ".repeat(indent) : "";
-  return [
-    indentStr + `style ${target} {`,
-    ...entries(style).map(([key, value]) => indentStr + `  ${key} ${value}`),
-    indentStr + `}`
-  ].join("\n");
-};
-const isMatchingViewRule = (fqn, index) => (rule) => {
-  if (!ast.isViewRuleStyle(rule)) {
-    return false;
-  }
-  const [target, ...rest] = rule.targets;
-  if (!target || rest.length > 0 || !ast.isElementRef(target)) {
-    return false;
-  }
-  const ref = target.el.ref;
-  const _fqn = ref ? index.getFqn(ref) : null;
-  return _fqn === fqn;
-};
-export function changeElementStyle(services, {
-  view,
-  viewAst,
-  targets,
-  style
-}) {
-  const viewCstNode = viewAst.$cstNode;
-  invariant(viewCstNode, "viewCstNode");
-  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? last(viewAst.body.props)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.start;
-  invariant(insertPos, "insertPos is not defined");
-  const indent = viewCstNode.range.start.character + 2;
-  const fqnIndex = services.likec4.FqnIndex;
-  const styleRules = viewAst.body.rules.filter(ast.isViewRuleStyle);
-  const viewOf = view.viewOf;
-  const existing = [];
-  const insert = [];
-  targets.forEach((target) => {
-    const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex));
-    const fqn = viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target;
-    if (rule) {
-      existing.push({ fqn, rule });
-    } else {
-      insert.push({ fqn });
-    }
-  });
-  const modifiedRange = {
-    start: insertPos,
-    end: insertPos
-  };
-  const includeRange = (range) => {
-    if (range.start.line <= modifiedRange.start.line) {
-      if (range.start.line == modifiedRange.start.line) {
-        modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character);
-      } else {
-        modifiedRange.start.line = range.start.line;
-        modifiedRange.start.character = range.start.character;
-      }
-    }
-    if (range.end.line >= modifiedRange.end.line) {
-      if (range.end.line == modifiedRange.end.line) {
-        modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character);
-      } else {
-        modifiedRange.end.line = range.end.line;
-        modifiedRange.end.character = range.end.character;
-      }
-    }
-  };
-  const edits = [];
-  if (insert.length > 0) {
-    const linesToInsert = [
-      "",
-      ...insert.map(({ fqn }) => asViewStyleRule(fqn, style, indent))
-    ];
-    edits.push(
-      TextEdit.insert(
-        insertPos,
-        linesToInsert.join("\n")
-      )
-    );
-    modifiedRange.start = {
-      line: insertPos.line + 1,
-      character: indent
-    };
-    modifiedRange.end = {
-      line: insertPos.line + linesToInsert.length,
-      character: indent + (last(linesToInsert)?.length ?? 0) + 1
-    };
-  }
-  if (existing.length > 0) {
-    for (const { rule } of existing) {
-      const ruleCstNode = rule.$cstNode;
-      invariant(ruleCstNode, "RuleCstNode not found");
-      for (const [key, _value] of entries.strict(style)) {
-        const value = isNumber(_value) ? _value.toString() + "%" : _value;
-        const ruleProp = rule.styleprops.find((p) => p.key === key);
-        if (ruleProp && ruleProp.$cstNode) {
-          const { range: { start, end } } = nonNullable(
-            findNodeForProperty(ruleProp.$cstNode, "value"),
-            "cant find value cst node"
-          );
-          includeRange({
-            start,
-            end: {
-              line: end.line,
-              character: start.character + value.length + 1
-            }
-          });
-          edits.push(TextEdit.replace({ start, end }, value));
-          continue;
-        }
-        const insertPos2 = findNodeForKeyword(ruleCstNode, "{")?.range.end;
-        invariant(insertPos2, "Opening brace not found");
-        const indentStr = " ".repeat(2 + ruleCstNode.range.start.character);
-        const insertKeyValue = indentStr + key + " " + value;
-        edits.push(
-          TextEdit.insert(
-            insertPos2,
-            "\n" + insertKeyValue
-          )
-        );
-        includeRange({
-          start: {
-            line: insertPos2.line + 1,
-            character: indentStr.length + 1
-          },
-          end: {
-            line: insertPos2.line + 1,
-            character: insertKeyValue.length + 1
-          }
-        });
-      }
-    }
-  }
-  return edits;
-}

package/dist/model-change/changeViewLayout.d.ts

@@ -1,13 +0,0 @@
-import { type AutoLayoutDirection } from '@likec4/core';
-import { TextEdit } from 'vscode-languageserver-protocol';
-import { ast, type ParsedAstElementView, type ParsedLikeC4LangiumDocument } from '../ast';
-import type { LikeC4Services } from '../module';
-type ChangeViewLayoutArg = {
-    view: ParsedAstElementView;
-    doc: ParsedLikeC4LangiumDocument;
-    viewAst: ast.ElementView;
-    layout: AutoLayoutDirection;
-};
-export declare function changeViewLayout(services: LikeC4Services, { view, viewAst, layout }: ChangeViewLayoutArg): TextEdit[];
-export {};
-//# sourceMappingURL=changeViewLayout.d.ts.map