insomnia-plugin-jsonc 0.1.0 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2026 Guillaume Ongenae
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,16 +1,77 @@
 # insomnia-plugin-jsonc
 
-Strip JSON comments from your request body.
+Write comments and trailing commas in your JSON request bodies. They are stripped before the request is sent.
+
+- **The original**: published on npm in January 2022, before the other JSON comments plugins for Insomnia.
+- **The fastest**: 3 to 10 times faster than [`strip-json-comments`](https://github.com/sindresorhus/strip-json-comments), and up to 20 times faster on large bodies than the regular expression other plugins use. See [`bench/`](bench/README.md).
+- **Unbreakable**: handles the cases other implementations get wrong, such as a string ending with an escaped backslash (`"C:\\dir\\"`) or a line comment ended by a lone `\r`. Strings are never altered, empty and malformed bodies never make it throw, and the body is scanned in linear time, even on malformed input. No runtime dependencies, no network access.
+
+## Example
+
+What you write in Insomnia:
+
+<!-- prettier-ignore -->
+```jsonc
+{
+  "page": 1, // current page
+  /* "debug": true, */
+  "url": "https://example.com", // `//` inside strings is kept
+  "tags": ["a", "b",],
+}
+```
+
+What the server receives:
+
+```json
+{
+  "page": 1,
+
+  "url": "https://example.com",
+  "tags": ["a", "b"]
+}
+```
 
 ## Installation
 
-- Open Insomnia options (Ctrl + , | Cmd + ,)
-- Type `insomnia-plugin-jsonc` on the Plugins tab
+### Plugin Hub
+
+Install from the [Insomnia Plugin Hub](https://insomnia.rest/plugins/insomnia-plugin-jsonc).
+
+### From Insomnia
+
+1. Open Preferences (Ctrl + , | Cmd + ,)
+2. Go to the Plugins tab
+3. Enter `insomnia-plugin-jsonc` and click Install Plugin
+
+### Manually
+
+Copy this folder into the Insomnia plugins directory:
+
+- Windows: `%APPDATA%\Insomnia\plugins\`
+- macOS: `~/Library/Application Support/Insomnia/plugins/`
+- Linux: `~/.config/Insomnia/plugins/`
+
+## What is stripped
+
+- Line comments: `// ...` up to the end of the line
+- Block comments: `/* ... */`, which can span several lines
+- Trailing commas before `]` or `}`, even with a comment in between
+
+Content inside strings is never touched, so `"https://example.com"` or `"a /* b */"` stay as they are.
+
+The plugin only applies to JSON bodies: `application/json`, with or without parameters (`application/json; charset=utf-8`), and `+json` types (`application/vnd.api+json`). Other bodies are sent unchanged.
+
+## Limitations
+
+- Whitespace around a removed comment is kept, so the sent body may contain extra spaces or blank lines.
+- The result is not validated: invalid JSON is sent as is, and the server reports the error.
+
+## How it works
 
-## Usage
+A request hook scans the body once, character by character, jumping over strings and comments. It removes comments and trailing commas, and copies the rest as is: the body is not parsed and serialized again, so its formatting is preserved. A body with nothing to strip is returned untouched.
 
-Just write valid JavaScript comments in JSON body request and send your request without minding them.
+See [`bench/`](bench/README.md) for a comparison with a regular expression, another scanner and [`strip-json-comments`](https://github.com/sindresorhus/strip-json-comments).
 
-## Deps
+## License
 
-Use [`json-easy-strip`](https://www.npmjs.com/package/json-easy-strip)'s RegExp to strip comments.
+MIT

package/cover.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 400" width="1200" height="400">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#4000BF"/>
+      <stop offset="1" stop-color="#2A0080"/>
+    </linearGradient>
+  </defs>
+  <rect width="1200" height="400" fill="url(#bg)"/>
+  <!-- { } logo -->
+  <g transform="translate(80 72) scale(0.5)">
+    <g fill="none" stroke="#FFFFFF" stroke-width="32" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M176 112h-16c-24 0-40 16-40 40v56c0 24-16 48-40 48 24 0 40 24 40 48v56c0 24 16 40 40 40h16"/>
+      <path d="M336 112h16c24 0 40 16 40 40v56c0 24 16 48 40 48-24 0-40 24-40 48v56c0 24-16 40-40 40h-16"/>
+    </g>
+    <g stroke="#B794FF" stroke-width="28" stroke-linecap="round">
+      <path d="M196 312l40-112"/>
+      <path d="M276 312l40-112"/>
+    </g>
+  </g>
+  <g font-family="Menlo, Consolas, 'DejaVu Sans Mono', monospace">
+    <text x="400" y="190" font-size="64" font-weight="bold" fill="#FFFFFF">JSON Comments</text>
+    <text x="400" y="250" font-size="30" fill="#D9C7FF">Strips comments from JSON request bodies.</text>
+    <!-- before → after -->
+    <text x="400" y="318" font-size="24" fill="#FFFFFF">{"a": 1<tspan fill="#B794FF" text-decoration="line-through">, /* note */</tspan>}</text>
+    <text x="720" y="318" font-size="24" fill="#B794FF">→</text>
+    <text x="770" y="318" font-size="24" fill="#FFFFFF">{"a": 1}</text>
+  </g>
+</svg>

package/icon.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
+  <rect width="512" height="512" rx="96" fill="#4000BF"/>
+  <!-- { } -->
+  <g fill="none" stroke="#FFFFFF" stroke-width="32" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M176 112h-16c-24 0-40 16-40 40v56c0 24-16 48-40 48 24 0 40 24 40 48v56c0 24 16 40 40 40h16"/>
+    <path d="M336 112h16c24 0 40 16 40 40v56c0 24 16 48 40 48-24 0-40 24-40 48v56c0 24-16 40-40 40h-16"/>
+  </g>
+  <!-- // -->
+  <g stroke="#B794FF" stroke-width="28" stroke-linecap="round">
+    <path d="M196 312l40-112"/>
+    <path d="M276 312l40-112"/>
+  </g>
+</svg>

package/main.js

@@ -1,34 +1,38 @@
+const { stripJSONC } = require("./strip");
+
 /**
  * JSON Content-Type
  */
 const CONTENT_TYPE_JSON = "application/json";
 
 /**
- * Strip comments from a JSON string
- *
- * Taken from [`json-easy-strip`](https://www.npmjs.com/package/json-easy-strip).
+ * Check if a MIME type is JSON, ignoring its parameters
  *
- * Extracted to not parse and stringify again the JSON string
+ * Matches `application/json` and structured syntax suffixes like `application/vnd.api+json`.
  *
- * @param data the JSON string with comments
- * @returns the JSON string without comments
+ * @param mimeType the MIME type, possibly with parameters (`application/json; charset=utf-8`)
+ * @returns whether the MIME type is JSON
  */
-const stripJSONComments = (data) =>
-  data.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) =>
-    g ? "" : m
-  );
+const isJSONMimeType = (mimeType) => {
+  const type = String(mimeType ?? "")
+    .split(";")[0]
+    .trim()
+    .toLowerCase();
+  return type === CONTENT_TYPE_JSON || type.endsWith("+json");
+};
 
 /**
- * Hook to update request body and remove comments
+ * Hook to update request body and remove comments and trailing commas
  * @param context insomnia request context
  * @link https://docs.insomnia.rest/insomnia/context-object-reference
  */
 const updateRequestBodyHook = (context) => {
   const body = context.request.getBody();
-  if (body.mimeType === CONTENT_TYPE_JSON) {
+  // `text` is undefined on an empty body
+  if (isJSONMimeType(body.mimeType) && typeof body.text === "string") {
     context.request.setBody({
       ...body,
-      text: stripJSONComments(body.text),
+      text: stripJSONC(body.text),
     });
   }
 };

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "insomnia-plugin-jsonc",
-  "version": "0.1.0",
-  "description": "Insomnia plugin to use comments in JSON body",
+  "version": "0.2.1",
+  "description": "Write // and /* */ comments in JSON request bodies in Insomnia",
   "main": "main.js",
+  "files": [
+    "main.js",
+    "strip.js",
+    "icon.svg",
+    "cover.svg"
+  ],
   "insomnia": {
     "name": "jsonc",
-    "displayName": "JSON Comments Plugin",
-    "description": "Plugin to use comments in JSON body.",
+    "displayName": "JSON Comments & Trailing Commas",
+    "description": "Strips comments from JSON request bodies.",
+    "images": {
+      "icon": "icon.svg",
+      "cover": "cover.svg"
+    },
     "publisher": {
       "name": "Guillaume Ongenae",
       "icon": "https://avatars.githubusercontent.com/u/9453090"
@@ -14,11 +24,14 @@
     "unlisted": false
   },
   "scripts": {
-    "test": "node test.js"
+    "test": "node --test test.js",
+    "prepublishOnly": "npm test",
+    "format": "npx prettier@3 --write .",
+    "bench": "node --expose-gc bench/bench.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/algoan/insomnia-plugin-jsonc.git"
+    "url": "git+ssh://git@github.com/g-ongenae/insomnia-plugin-jsonc.git"
   },
   "keywords": [
     "insomnia",
@@ -33,6 +46,8 @@
     "url": "https://github.com/g-ongenae/insomnia-plugin-jsonc/issues"
   },
   "homepage": "https://github.com/g-ongenae/insomnia-plugin-jsonc#readme",
-  "dependencies": {},
-  "devDependencies": {}
+  "devDependencies": {
+    "fast-check": "^4.10.2",
+    "strip-json-comments": "^5.0.3"
+  }
 }

package/strip.js

@@ -0,0 +1,150 @@
+const QUOTE = 34; // "
+const SLASH = 47; // /
+const STAR = 42; // *
+const BACKSLASH = 92; // \
+const COMMA = 44; // ,
+const CLOSING_BRACKET = 93; // ]
+const CLOSING_BRACE = 125; // }
+
+/**
+ * Check if a character code is JSON whitespace
+ * @param code the character code
+ * @returns whether it is a space, a tab, a line feed or a carriage return
+ */
+const isWhitespace = (code) =>
+  code === 32 || code === 10 || code === 13 || code === 9;
+
+/**
+ * Check if a character code ends a line comment
+ *
+ * Same line terminators as JavaScript, which `.` does not match in the previous regex.
+ *
+ * @param code the character code
+ * @returns whether it is `\n`, `\r`, `\u2028` or `\u2029`
+ */
+const isLineTerminator = (code) =>
+  code === 10 || code === 13 || code === 0x2028 || code === 0x2029;
+
+/**
+ * Find the end of the line comment opening at `start`
+ *
+ * The line terminator is kept, so that the line structure is preserved.
+ *
+ * @param data the JSONC string
+ * @param start the index of the comment's first slash
+ * @returns the index of the line terminator, or the length of the string
+ */
+const skipLineComment = (data, start) => {
+  let i = start + 2;
+  while (i < data.length && !isLineTerminator(data.charCodeAt(i))) i++;
+  return i;
+};
+
+/**
+ * Find the end of the string opening at `start`
+ *
+ * A quote preceded by an odd number of backslashes is escaped, so `"C:\\"` ends on its last quote.
+ *
+ * @param data the JSONC string
+ * @param start the index of the opening quote
+ * @returns the index after the closing quote, or -1 if the string is not terminated
+ */
+const skipString = (data, start) => {
+  let i = start;
+  for (;;) {
+    const quote = data.indexOf('"', i + 1);
+    if (quote === -1) return -1;
+    let backslash = quote - 1;
+    while (data.charCodeAt(backslash) === BACKSLASH) backslash--;
+    if ((quote - 1 - backslash) % 2 === 0) return quote + 1;
+    i = quote;
+  }
+};
+
+/**
+ * Strip comments and trailing commas from a JSONC string
+ *
+ * Scans the string once, jumping over strings and comments with `indexOf`, and copies
+ * the kept text by slices. The string is returned as is when nothing is removed.
+ *
+ * An unterminated block comment is kept, so that invalid JSON is sent as is.
+ *
+ * @param data the JSONC string
+ * @returns the JSON string
+ */
+const stripJSONC = (data) => {
+  const length = data.length;
+  /** Kept slices, only allocated once something is removed */
+  let parts = null;
+  /** First index not copied to `parts` yet */
+  let start = 0;
+  /** Index of a comma only followed by whitespace or comments so far */
+  let comma = -1;
+  /** Index in `parts` of that comma, once copied */
+  let commaPart = -1;
+  /** Whether a block comment can still be closed, to not search the rest again for each opening */
+  let hasBlockEnd = true;
+
+  const flush = (end) => {
+    parts ??= [];
+    if (end > start) parts.push(data.slice(start, end));
+  };
+
+  // Copy a pending comma in its own part, to be able to drop it on a closing bracket
+  const detachComma = () => {
+    if (comma === -1 || commaPart !== -1) return;
+    flush(comma);
+    commaPart = parts.push(",") - 1;
+    start = comma + 1;
+  };
+
+  for (let i = 0; i < length;) {
+    const code = data.charCodeAt(i);
+    if (code === QUOTE) {
+      const end = skipString(data, i);
+      if (end === -1) break;
+      comma = -1;
+      i = end;
+    } else if (code === SLASH && data.charCodeAt(i + 1) === SLASH) {
+      detachComma();
+      flush(i);
+      i = start = skipLineComment(data, i);
+    } else if (
+      code === SLASH &&
+      data.charCodeAt(i + 1) === STAR &&
+      hasBlockEnd
+    ) {
+      const end = data.indexOf("*/", i + 2);
+      if (end === -1) {
+        // No later block comment can be terminated either
+        hasBlockEnd = false;
+        continue;
+      }
+      detachComma();
+      flush(i);
+      i = start = end + 2;
+    } else if (code === COMMA) {
+      comma = i;
+      commaPart = -1;
+      i++;
+    } else if (code === CLOSING_BRACKET || code === CLOSING_BRACE) {
+      if (comma !== -1 && commaPart !== -1) {
+        parts[commaPart] = "";
+      } else if (comma !== -1) {
+        flush(comma);
+        start = comma + 1;
+      }
+      comma = -1;
+      i++;
+    } else {
+      if (!isWhitespace(code)) comma = -1;
+      i++;
+    }
+  }
+
+  if (parts === null) return data;
+  flush(length);
+  return parts.join("");
+};
+
+module.exports = { stripJSONC };

package/test.js

@@ -1,44 +0,0 @@
-const { requestHooks } = require('./main');
-
-/**
- * Create a fake insomnia context with a validation on the setBody
- * @param {object} givenBody
- * @param {object} expectedBody
- * @returns a fake insomnia context with a validation
- */
-const fakeContext = (id, givenBody, expectedBody) => {
-  return {
-    request: {
-      getBody: () => givenBody,
-      setBody: (actualBody) => {
-        const result = actualBody.text === expectedBody.text
-          ? `${id} | passed`
-          : `${id} | expected: '${expectedBody.text}' => received: '${actualBody.text}'`;
-
-        console.log(result);
-      },
-    }
-  };
-};
-
-/**
- * List of test cases
- */
-const cases = [
-  // Should not alter non JSON body
-  [{ mimeType: 'non-json', text: 'foo' }, { mimeType: 'non-json', text: 'foo' }],
-  // Should not alter JSON body without comments
-  [{ mimeType: 'application/json', text: 'foo' }, { mimeType: 'application/json', text: 'foo' }],
-  [{ mimeType: 'application/json', text: '{"foo": "bar"}' }, { mimeType: 'application/json', text: '{"foo": "bar"}' }],
-  // Should remove comments from JSON body (space are preserved)
-  [{ mimeType: 'application/json', text: '{"foo": /* hello */ "bar"}' }, { mimeType: 'application/json', text: '{"foo":  "bar"}' }],
-  [{ mimeType: 'application/json', text: '/* hello */ {"foo": "bar"}' }, { mimeType: 'application/json', text: ' {"foo": "bar"}' }],
-  [{ mimeType: 'application/json', text: '{"foo": "bar" // hello\n }' }, { mimeType: 'application/json', text: '{"foo": "bar" \n }' }],
-];
-
-/**
- * Call and test the hook
- */
-for (const [index, test] of Object.entries(cases)) {
-  requestHooks[0](fakeContext(index, ...test));
-}