@vesk/prettier-plugin 0.0.1

package/README.md

@@ -0,0 +1,21 @@
+# @vesk/prettier-plugin
+
+Prettier plugin for the Vesk component language (`.vsk` files).
+
+## Install
+
+```sh
+npm install @vesk/prettier-plugin prettier
+```
+
+## Usage
+
+```json
+{
+  "plugins": ["@vesk/prettier-plugin"]
+}
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@vesk/prettier-plugin",
+  "version": "0.0.1",
+  "description": "Prettier plugin for the Vesk component language",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "default": "./src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "prettier",
+    "plugin",
+    "vesk",
+    "formatter"
+  ],
+  "license": "MIT",
+  "author": "emeraldlinks",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/emeraldlinks/veskTs.git"
+  },
+  "homepage": "https://github.com/emeraldlinks/veskTs#readme",
+  "bugs": {
+    "url": "https://github.com/emeraldlinks/veskTs/issues"
+  },
+  "peerDependencies": {
+    "prettier": "^3.0.0"
+  },
+  "dependencies": {
+    "@vesk/compiler": "^0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/comments.js

@@ -0,0 +1,145 @@
+/**
+ * Attaches comments (collected via acorn's `onComment`) to AST nodes so the
+ * printer can emit them. Comments are attached as `leadingComments` /
+ * `trailingComments` on statement-list items and block bodies; anything that
+ * falls outside a statement list is attached to the innermost containing node
+ * as `innerComments`.
+ */
+
+function isNode(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof value.type === 'string' &&
+    typeof value.start === 'number'
+  );
+}
+
+function sameLine(a, b) {
+  return a.loc && b.loc && a.loc.end.line === b.loc.start.line;
+}
+
+/** Statement/child lists where comments between members matter. */
+function childArrays(node) {
+  const lists = [];
+  if (!isNode(node)) return lists;
+  switch (node.type) {
+    case 'Program':
+      lists.push(node.body);
+      break;
+    case 'BlockStatement':
+      lists.push(node.body);
+      break;
+    case 'SwitchCase':
+      lists.push(node.consequent);
+      break;
+    case 'ClassBody':
+      lists.push(node.body);
+      break;
+    case 'TSInterfaceBody':
+      lists.push(node.body);
+      break;
+    case 'JSXElement':
+    case 'JSXFragment':
+      lists.push(node.children || []);
+      break;
+    case 'TSTypeLiteral':
+      lists.push(node.members || node.body || []);
+      break;
+  }
+  return lists;
+}
+
+function collectNodes(node, out) {
+  if (!isNode(node)) return;
+  out.push(node);
+  for (const key of Object.keys(node)) {
+    if (key === 'loc' || key === 'range' || key === 'start' || key === 'end' || key === 'leadingComments' || key === 'trailingComments' || key === 'innerComments') continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) collectNodes(item, out);
+    } else if (isNode(value)) {
+      collectNodes(value, out);
+    }
+  }
+}
+
+function findInnermostContainer(ast, pos) {
+  let best = null;
+  const nodes = [];
+  collectNodes(ast, nodes);
+  for (const n of nodes) {
+    if (n.start <= pos && pos <= n.end) {
+      if (!best || n.end - n.start < best.end - best.start) best = n;
+    }
+  }
+  return best;
+}
+
+/**
+ * Recursively distributes comments into statement/child lists, then falls back
+ * to attaching unhandled comments as innerComments of their container.
+ */
+export function attachComments(ast, comments) {
+  if (!comments || comments.length === 0) return;
+  const remaining = comments.slice().sort((a, b) => a.start - b.start);
+
+  const processList = (children) => {
+    if (!Array.isArray(children) || children.length === 0) return;
+    for (let i = 0; i < remaining.length; i++) {
+      const c = remaining[i];
+      let idx = -1;
+      for (let j = 0; j < children.length; j++) {
+        if (children[j].start >= c.end) { idx = j; break; }
+      }
+      if (idx === -1) {
+        // Comment after the last child — attach as a trailing comment if it
+        // starts on the same line as the previous child.
+        const last = children[children.length - 1];
+        if (last && sameLine(last, c)) {
+          (last.trailingComments ||= []).push(c);
+          remaining.splice(i, 1);
+          i--;
+        }
+        continue;
+      }
+      const child = children[idx];
+      const prev = idx > 0 ? children[idx - 1] : null;
+      if (prev && sameLine(prev, c)) {
+        (prev.trailingComments ||= []).push(c);
+        remaining.splice(i, 1);
+        i--;
+      } else {
+        (child.leadingComments ||= []).push(c);
+        remaining.splice(i, 1);
+        i--;
+      }
+    }
+  };
+
+  const walk = (node) => {
+    if (!isNode(node)) return;
+    // Recurse into children first so comments that live inside a nested
+    // statement list are claimed by the deepest list before an enclosing
+    // list (Program/block body) can snap them up as leading comments.
+    for (const key of Object.keys(node)) {
+      if (['loc', 'range', 'start', 'end', 'leadingComments', 'trailingComments', 'innerComments'].includes(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) walk(item);
+      } else if (isNode(value)) {
+        walk(value);
+      }
+    }
+    for (const list of childArrays(node)) processList(list);
+  };
+
+  walk(ast);
+
+  // Any comment still unplaced is attached as an inner comment of the smallest
+  // node that contains it.
+  for (const c of remaining) {
+    const container = findInnermostContainer(ast, c.start);
+    if (container) (container.innerComments ||= []).push(c);
+  }
+}

package/src/index.js

@@ -0,0 +1,77 @@
+import { createBaseParser } from '@vesk/compiler';
+import { preprocessForClauses } from '@vesk/compiler/src/parser';
+import { attachComments } from './comments.js';
+import { printVeskNode } from './print.js';
+
+export const languages = [
+  {
+    name: 'vesk',
+    parsers: ['vesk'],
+    extensions: ['.vsk'],
+    vscodeLanguageIds: ['vsk'],
+    tmScope: 'source.vsk',
+  },
+];
+
+/**
+ * @param {string} text
+ * @param {import('prettier').ParserOptions} options
+ * @returns {import('estree').Program}
+ */
+function parseVesk(text, options) {
+  const parser = createBaseParser();
+  const { code, annotations } = preprocessForClauses(text);
+  const comments = [];
+  const ast = parser.parse(code, {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    locations: true,
+    ranges: true,
+    ...(options.filepath ? { sourceFilename: options.filepath } : {}),
+    onComment: comments,
+  });
+
+  if (annotations.length > 0) {
+    ast.__vskAnnotations = annotations;
+  }
+  // The printer splices `; key …` / `; index …` clauses back from the original
+  // text, so stash both on the options object used by print().
+  options.__vskAnnotations = annotations;
+
+  attachComments(ast, comments);
+
+  return ast;
+}
+
+/**
+ * @param {import('estree').Node} node
+ * @returns {number}
+ */
+function locStart(node) {
+  return node.start;
+}
+
+/**
+ * @param {import('estree').Node} node
+ * @returns {number}
+ */
+function locEnd(node) {
+  return node.end;
+}
+
+export const parsers = {
+  vesk: {
+    astFormat: 'vesk-ast',
+    parse: parseVesk,
+    locStart,
+    locEnd,
+  },
+};
+
+export const printers = {
+  'vesk-ast': {
+    print: printVeskNode,
+  },
+};
+
+export default { languages, parsers, printers };