insomnia-plugin-jsonc 0.2.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

@@ -2,10 +2,15 @@
 
 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
@@ -63,7 +68,9 @@ The plugin only applies to JSON bodies: `application/json`, with or without para
 
 ## How it works
 
-A request hook strips comments with a regular expression adapted from [`json-easy-strip`](https://www.npmjs.com/package/json-easy-strip), then removes trailing commas. The body is not parsed and serialized again, so its formatting is preserved.
+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.
+
+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).
 
 ## License
 

package/main.js

@@ -14,7 +14,10 @@ const CONTENT_TYPE_JSON = "application/json";
  * @returns whether the MIME type is JSON
  */
 const isJSONMimeType = (mimeType) => {
-  const type = String(mimeType ?? "").split(";")[0].trim().toLowerCase();
+  const type = String(mimeType ?? "")
+    .split(";")[0]
+    .trim()
+    .toLowerCase();
   return type === CONTENT_TYPE_JSON || type.endsWith("+json");
 };
 

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "insomnia-plugin-jsonc",
-  "version": "0.2.0",
-  "description": "Insomnia plugin to strip JSON body comments",
+  "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",
+    "displayName": "JSON Comments & Trailing Commas",
     "description": "Strips comments from JSON request bodies.",
     "images": {
       "icon": "icon.svg",
@@ -18,7 +24,10 @@
     "unlisted": false
   },
   "scripts": {
-    "test": "node --test 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",
@@ -38,6 +47,7 @@
   },
   "homepage": "https://github.com/g-ongenae/insomnia-plugin-jsonc#readme",
   "devDependencies": {
-    "fast-check": "^4.10.2"
+    "fast-check": "^4.10.2",
+    "strip-json-comments": "^5.0.3"
   }
 }

package/strip.js

@@ -1,40 +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;
+
 /**
- * Strip comments from a JSON string
+ * Check if a character code ends a line comment
  *
- * Adapted from [`json-easy-strip`](https://www.npmjs.com/package/json-easy-strip),
- * with strings matched as a whole (any escaped character included) so that
- * an escaped backslash before a closing quote is handled.
+ * 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`
  *
- * Extracted to not parse and stringify again the JSON string
+ * The line terminator is kept, so that the line structure is preserved.
  *
- * @param data the JSON string with comments
- * @returns the JSON string without comments
+ * @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 stripJSONComments = (data) =>
-  data.replace(/"(?:\\.|[^"\\])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) =>
-    g ? "" : m
-  );
+const skipLineComment = (data, start) => {
+  let i = start + 2;
+  while (i < data.length && !isLineTerminator(data.charCodeAt(i))) i++;
+  return i;
+};
 
 /**
- * Strip trailing commas before a closing `]` or `}` from a JSON string
+ * Find the end of the string opening at `start`
  *
- * Must run after `stripJSONComments`, so that a comment between the comma
- * and the closing bracket does not hide it.
+ * A quote preceded by an odd number of backslashes is escaped, so `"C:\\"` ends on its last quote.
  *
- * @param data the JSON string without comments
- * @returns the JSON string without trailing commas
+ * @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 stripTrailingCommas = (data) =>
-  data.replace(/"(?:\\.|[^"\\])*"|,(\s*[\]}])/g, (m, g) =>
-    g === undefined ? m : g
-  );
+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) => stripTrailingCommas(stripJSONComments(data));
+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 = { stripJSONComments, stripTrailingCommas, stripJSONC };
+module.exports = { stripJSONC };

package/test.js

@@ -1,92 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fc = require('fast-check');
-const { requestHooks } = require('./main');
-const { stripJSONC } = require('./strip');
-
-/**
- * Run the hook on a fake insomnia context
- * @param {object} givenBody the body returned by getBody
- * @returns the list of bodies passed to setBody
- */
-const runHook = (givenBody) => {
-  const calls = [];
-  requestHooks[0]({
-    request: {
-      getBody: () => givenBody,
-      setBody: (body) => calls.push(body),
-    },
-  });
-  return calls;
-};
-
-/**
- * List of test cases: [name, given body, expected body]
- */
-const cases = [
-  ['should not alter invalid JSON body without comments', { mimeType: 'application/json', text: 'foo' }, { mimeType: 'application/json', text: 'foo' }],
-  ['should not alter JSON body without comments', { mimeType: 'application/json', text: '{"foo": "bar"}' }, { mimeType: 'application/json', text: '{"foo": "bar"}' }],
-  // Spaces around comments are preserved
-  ['should remove inline block comment', { mimeType: 'application/json', text: '{"foo": /* hello */ "bar"}' }, { mimeType: 'application/json', text: '{"foo":  "bar"}' }],
-  ['should remove leading block comment', { mimeType: 'application/json', text: '/* hello */ {"foo": "bar"}' }, { mimeType: 'application/json', text: ' {"foo": "bar"}' }],
-  ['should remove line comment after the last item', { mimeType: 'application/json', text: '{"a": 1 // last\n}' }, { mimeType: 'application/json', text: '{"a": 1 \n}' }],
-  ['should remove line comment', { mimeType: 'application/json', text: '{"foo": "bar" // hello\n }' }, { mimeType: 'application/json', text: '{"foo": "bar" \n }' }],
-  ['should remove trailing comma in object', { mimeType: 'application/json', text: '{"a": 1, }' }, { mimeType: 'application/json', text: '{"a": 1 }' }],
-  ['should remove trailing comma in array', { mimeType: 'application/json', text: '[1,\n]' }, { mimeType: 'application/json', text: '[1\n]' }],
-  ['should remove trailing comma followed by a comment', { mimeType: 'application/json', text: '{"a": 1, // last\n}' }, { mimeType: 'application/json', text: '{"a": 1 \n}' }],
-  ['should remove trailing comma followed by a block comment', { mimeType: 'application/json', text: '[1, /* last */]' }, { mimeType: 'application/json', text: '[1 ]' }],
-  ['should not remove comma-like content in strings', { mimeType: 'application/json', text: '{"a": ",}", "b": ",]"}' }, { mimeType: 'application/json', text: '{"a": ",}", "b": ",]"}' }],
-  ['should handle JSON MIME type with parameters', { mimeType: 'application/json; charset=utf-8', text: '{"a": 1 /* b */}' }, { mimeType: 'application/json; charset=utf-8', text: '{"a": 1 }' }],
-  ['should handle JSON MIME type case-insensitively', { mimeType: 'Application/JSON', text: '{"a": 1 /* b */}' }, { mimeType: 'Application/JSON', text: '{"a": 1 }' }],
-  ['should handle +json MIME types', { mimeType: 'application/vnd.api+json', text: '{"a": 1 /* b */}' }, { mimeType: 'application/vnd.api+json', text: '{"a": 1 }' }],
-];
-
-test('should not call setBody on non JSON body', () => {
-  assert.deepEqual(runHook({ mimeType: 'non-json', text: 'foo // bar' }), []);
-  assert.deepEqual(runHook({ mimeType: 'application/jsonp', text: 'foo // bar' }), []);
-  assert.deepEqual(runHook({ text: 'foo // bar' }), []);
-});
-
-test('should not throw nor call setBody on empty JSON body', () => {
-  assert.deepEqual(runHook({ mimeType: 'application/json' }), []);
-});
-
-for (const [name, givenBody, expectedBody] of cases) {
-  test(name, () => {
-    const calls = runHook(givenBody);
-    assert.equal(calls.length, 1);
-    assert.equal(calls[0].text, expectedBody.text);
-  });
-}
-
-test('should keep comment-like content in a string after an escaped backslash', () => {
-  const text = String.raw`{"a": "x\\", "b": "// y"}`;
-  const [body] = runHook({ mimeType: 'application/json', text });
-  assert.equal(body.text, text);
-  assert.deepEqual(JSON.parse(body.text), { a: 'x\\', b: '// y' });
-});
-
-test('should strip comments and trailing commas inserted in any JSON document', () => {
-  const comment = fc.string({ unit: 'grapheme-ascii' }).filter((c) => !c.includes('*/'));
-  const lineComments = fc.array(fc.record({ block: fc.option(comment), line: fc.option(comment), trailingComma: fc.boolean() }));
-
-  fc.assert(
-    fc.property(fc.jsonValue(), lineComments, (value, comments) => {
-      // JSON.stringify escapes newlines in strings, so each line starts and ends on a token boundary
-      const json = JSON.stringify(value, null, 2);
-      const text = json
-        .split('\n')
-        .map((line, i, lines) => {
-          const { block = null, line: lineComment = null, trailingComma = false } = comments[i] ?? {};
-          // A trailing comma is allowed after the last value of a non-empty array or object
-          const isLastValue = /^\s*[\]}]/.test(lines[i + 1] ?? '') && !/[[{]$/.test(line);
-          const comma = trailingComma && isLastValue ? ',' : '';
-          return `${block === null ? '' : `/*${block}*/`}${line}${comma}${lineComment === null ? '' : `//${lineComment}`}`;
-        })
-        .join('\n');
-
-      // Compare with the parsed original rather than `value`, since -0 does not survive JSON
-      assert.deepEqual(JSON.parse(stripJSONC(text)), JSON.parse(json));
-    }),
-  );
-});