JsonTools Notepad++ Plugin

JsonToolsNppPlugin provides a suite of tools for working with JSON within Notepad++:

• Formatting: Pretty-print JSON (multi-line) and Compress JSON (minimal whitespace).
• Navigation: A drop-down tree view where selecting a node navigates to the corresponding line in the document.
• Robust Parsing: Supports JSON5, Python-style comments, missing commas/colons, and unterminated structures.
• Querying & Editing:
  • Find/replace form
  • Array sorting form
  • RemesPath query language
  • Regex search form (for CSV or math-based find/replace)
• Data Management: Parse JSON Lines, fetch JSON from APIs or local files, and generate random JSON from a schema.
• Validation: JSON schema validation (including automatic validation based on filenames).
• Utilities: Automatic error checking after editing, selecting JSON within non-JSON files, and converting between JSON strings and raw text.

Boolean indexing allows you to select elements from an iterable (array or object) that satisfy a specific condition. The syntax uses the @ symbol to represent the current context.

Filtering Arrays

When applying a boolean index to an array, you can use a single boolean or an array of booleans of the same length.

• Single Boolean: If the condition is true, the whole array is returned. If false, an empty array [] is returned.
• Boolean Array: An array of booleans where each element corresponds to the index of the original array. Only elements where the boolean is true are kept.

Filtering Objects

When applying a boolean index to an object, you use an object of booleans with the exact same keys as the original object. Only the key-value pairs where the boolean value is true are kept.

Version Note (v5.5.0+)

Starting in v5.5.0, boolean indices can be applied to non-iterables (scalars) and one-boolean indices on objects return the original object instead of an array, allowing for further querying.

// Array filtering with boolean array
// Input: [1, 2, 3]
@[@ > @[0]] // Returns [2, 3]

// Object filtering
// Input: {"a": 1, "b": 2, "c": 3}
@[@ > @.a] // Returns {"b": 2, "c": 3}

The JSON tree view is designed to be responsive by loading nodes on-demand. For very large files, the plugin may limit the initial view to prevent Notepad++ from becoming unresponsive.

Large Array/Object Handling

If an array or object has more than 10,000 direct children (configurable via Settings->max_json_length_full_tree), the plugin automatically displays 10,000 evenly spaced children as pointers to maintain performance.

Toggling Full Tree View

You can use the View all subtrees checkbox on the JSON viewer form to toggle between viewing the full tree and only the direct children of the root.

• Warning: Checking this box for documents larger than 2.5 MB will trigger a warning, as loading the full tree for large documents can cause Notepad++ to become unresponsive for a long time.
• Scope: This checkbox only affects the current tree view and does not change global settings.

Vectorized operations allow functions to operate on entire arrays or objects. When a function is called on an array or object, the first argument typically references each individual element (or child) separately, while subsequent arguments can reference the entire collection.

Example: String multiplication s_mul(s, n) s_mul concatenates string s, n times.

• With Array input ["a", "cd", "b"]: s_mul(@, len(@)) returns ["aaa", "cdcdcd", "bbb"].

  • The first argument @ refers to each element ("a", then "cd", etc.).
  • The second argument len(@) refers to the length of the entire array (3).

• With Object input {"foo": "a", "bar": "cd"} (Requires v7.0+): s_mul(@, len(@)) returns {"foo": "aa", "bar": "cdcd"}.

  • The first argument @ refers to each value ("a", then "cd").
  • The second argument len(@) refers to the number of children in the object (2).

// Array example
s_mul(["a", "cd", "b"], len(@)) // returns ["aaa", "cdcdcd", "bbb"]

// Object example (v7.0+)
s_mul({"foo": "a", "bar": "cd"}, len(@)) // returns {"foo": "aa", "bar": "cdcd"}

JsonTools (v8.0+) supports localization by automatically detecting the user's preferred language from the Notepad++ configuration.

Translation Workflow:

1. Detection: JsonTools checks the Notepad++ nativeLang.xml config file (XPath: /NotepadPlus/Native-Langue/@name) to find the lowerEnglishName (e.g., galician).
2. Lookup: It searches the translation subdirectory within the JsonTools plugin folder for a file named {lowerEnglishName}.json5 (e.g., galician.json5).
3. Fallback: If no file is found or parsing fails, it defaults to English.

Important Notes:

• Notepad++ Version: Translation requires Notepad++ version 8 or newer to support separate plugin subdirectories.
• Lifecycle: Translation is only attempted once during Notepad++ startup. If you change the Notepad++ UI language, you must restart Notepad++ for JsonTools to update.
• Disabling: To force English while keeping a specific Notepad++ language, append _disabled to the translation filename (e.g., german_disabled.json5).

JsonTools uses a sorting logic similar to Windows applications (like Microsoft Word), which differs from Notepad++'s Unicode code point-based sorting.

Case-Sensitive Sorters

The following features use case-sensitive sorting:

• sorted and sort_by RemesPath functions.
• The sort form when Sort method is set to Default.
• Other RemesPath functions that perform sorting (unless otherwise specified).

Case-Insensitive Sorters

The following features use case-insensitive sorting:

• Object key sorting when the sort_keys global setting is true.
• Object key sorting when the sort_keys argument to the stringify RemesPath function is true.
• The sort form when Sort method is set to As strings (ignoring case).

Key Differences from Notepad++

1. Numbers: The JsonTools sort form ignores leading minus signs when ordering numbers; Notepad++ does not.
2. Non-ASCII Characters: JsonTools orders characters like ö culturally (e.g., between o and p), whereas Notepad++ places them at the end based on Unicode code points.
3. Case Order: In case-sensitive mode, JsonTools places uppercase letters after lowercase letters. Notepad++ does the opposite.
4. Alphabetical Respect: JsonTools respects alphabetical order (e.g., P follows o), while Notepad++ groups all uppercase letters before all lowercase letters in case-sensitive mode.