@systems-modeling/jupyterlab-sysml 0.52.0 → 0.53.0

package/build/fold.js

@@ -0,0 +1,107 @@
+"use strict";
+/*
+ * SysML 2 Pilot Implementation
+ * Copyright (c) 2020-2025 Mgnite Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * @license LGPL-3.0-or-later <http://spdx.org/licenses/LGPL-3.0-or-later>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sysmlFoldServiceSelection = sysmlFoldServiceSelection;
+var language_1 = require("@codemirror/language");
+function isInStringCommentOrVariable(state, pos) {
+    var tree = (0, language_1.syntaxTree)(state);
+    var node = tree.resolveInner(pos, 1);
+    while (node) {
+        var nodeType = node.type.name;
+        // Check if we're in a string, comment, or other non-code context
+        // Note that 'variableName' correesponds to a quoted name
+        if (nodeType === 'String' ||
+            nodeType === 'Comment' ||
+            nodeType === 'BlockComment' ||
+            nodeType === 'LineComment' ||
+            nodeType === 'variableName' ||
+            nodeType.toLowerCase().includes('string') ||
+            nodeType.toLowerCase().includes('comment')) {
+            return true;
+        }
+        node = node.parent;
+    }
+    return false;
+}
+function findMatchingCloseBrace(state, openPos) {
+    var docLength = state.doc.length;
+    var nest = 1;
+    var pos = openPos + 1;
+    while (pos < docLength && nest > 0) {
+        var char = state.sliceDoc(pos, pos + 1);
+        // Skip if we're in a string, comment, or variable
+        if (!isInStringCommentOrVariable(state, pos)) {
+            if (char === '{') {
+                nest++;
+            }
+            else if (char === '}') {
+                nest--;
+                if (nest === 0) {
+                    return pos;
+                }
+            }
+        }
+        pos++;
+    }
+    return null;
+}
+function computeFoldRange(state, lineStart, lineEnd) {
+    // Check the language first
+    var lang = state.facet(language_1.language);
+    if (!lang || lang.name !== 'sysml')
+        return null;
+    var lineText = state.sliceDoc(lineStart, lineEnd);
+    for (var i = 0; i < lineText.length; i++) {
+        var char = lineText[i];
+        if (char === '{') {
+            var absolutePos = lineStart + i;
+            // Check if this brace is in a string, comment, or variable
+            if (isInStringCommentOrVariable(state, absolutePos)) {
+                continue;
+            }
+            // Find the matching closing brace
+            var closePos = findMatchingCloseBrace(state, absolutePos);
+            if (closePos === null) {
+                return null;
+            }
+            // Check if the fold spans multiple lines
+            var openLine = state.doc.lineAt(absolutePos);
+            var closeLine = state.doc.lineAt(closePos);
+            if (openLine.number === closeLine.number) {
+                /* Do not fold the same line */
+                return null;
+            }
+            return { from: absolutePos, to: closePos };
+        }
+    }
+    return null;
+}
+function sysmlFoldServiceSelection(options) {
+    var mimeType = options.model.mimeType;
+    if (mimeType === 'text/x-sysml'
+        // In the newly created notebook, the first cell is initialized as 'text/plain'
+        // We check the language in the foldService as well to avoid misapplication.
+        || mimeType === 'text/plain') {
+        return [language_1.foldService.of(computeFoldRange)];
+    }
+    else {
+        return [];
+    }
+}

package/build/mode.js

@@ -34,114 +34,75 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineSysMLv2Mode = void 0;
-// tslint:disable-next-line
-require("codemirror/addon/mode/simple");
-var CodeMirror = __importStar(require("codemirror"));
-var SI_MODE = 'sysml';
-var P_MIME = 'text/x-sysml';
+exports.sysmlparser = void 0;
+var clike_1 = require("@codemirror/legacy-modes/mode/clike");
 var f_wordify = function (h, s) {
     var _a;
     return (__assign(__assign({}, h), (_a = {}, _a[s] = true, _a)));
 };
-function defineSysMLv2Mode() {
-    CodeMirror.defineMode(SI_MODE, function (gc_mode, gc_parser) {
-        return CodeMirror.getMode(gc_mode, {
-            name: 'clike',
-            keywords: [
-                "about", "abstract", "accept", "action", "actor", "after", "alias", "all", "allocate", "allocation",
-                "analysis", "and", "as", "assert", "assign", "assume", "at", "attribute", "bind", "binding", "by",
-                "calc", "case", "comment", "concern", "connect", "connection", "constant", "constraint", "crosses",
-                "decide", "def", "default", "defined", "dependency", "derived", "do", "doc", "else", "end", "entry",
-                "enum", "event", "exhibit", "exit", "expose", "filter", "first", "flow", "for", "fork", "frame", "from",
-                "hastype", "if", "implies", "import", "in", "include", "individual", "inout", "interface", "istype",
-                "item", "join", "language", "library", "locale", "loop", "merge", "message", "meta", "metadata", "new",
-                "nonunique", "not", "objective", "occurrence", "of", "or", "ordered", "out", "package", "parallel",
-                "part", "perform", "port", "private", "protected", "public", "redefines", "ref", "references", "render",
-                "rendering", "rep", "require", "requirement", "return", "satisfy", "send", "snapshot", "specializes",
-                "stakeholder", "standard", "state", "subject", "subsets", "succession", "terminate", "then",
-                "timeslice", "to", "transition", "until", "use", "variant", "variation", "verification", "verify",
-                "via", "view", "viewpoint", "when", "while", "xor"
-            ].reduce(f_wordify, {}),
-            defKeywords: [
-                "action", "allocation", "analysis", "attribute", "binding", "calc", "case", "comment", "concern",
-                "connection", "constraint", "def", "doc", "enum", "flow", "interface", "item", "metadata", "objective",
-                "occurrence", "package", "part", "port", "ref", "rendering", "rep", "requirement", "snapshot", "state",
-                "subject", "succession", "timeslice", "transition", "verification", "view", "viewpoint"
-            ].reduce(f_wordify, {}),
-            typeFirstDefinitions: true,
-            atoms: ['true', 'false', 'null'].reduce(f_wordify),
-            number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
-            modeProps: {
-                fold: ['brace'],
-            },
-            hooks: {
-                "'": function (stream) {
+exports.sysmlparser = (0, clike_1.clike)({
+    name: 'sysml',
+    keywords: [
+        "about", "abstract", "accept", "action", "actor", "after", "alias", "all", "allocate", "allocation",
+        "analysis", "and", "as", "assert", "assign", "assume", "at", "attribute", "bind", "binding", "by",
+        "calc", "case", "comment", "concern", "connect", "connection", "constant", "constraint", "crosses",
+        "decide", "def", "default", "defined", "dependency", "derived", "do", "doc", "else", "end", "entry",
+        "enum", "event", "exhibit", "exit", "expose", "filter", "first", "flow", "for", "fork", "frame", "from",
+        "hastype", "if", "implies", "import", "in", "include", "individual", "inout", "interface", "istype",
+        "item", "join", "language", "library", "locale", "loop", "merge", "message", "meta", "metadata", "new",
+        "nonunique", "not", "objective", "occurrence", "of", "or", "ordered", "out", "package", "parallel",
+        "part", "perform", "port", "private", "protected", "public", "redefines", "ref", "references", "render",
+        "rendering", "rep", "require", "requirement", "return", "satisfy", "send", "snapshot", "specializes",
+        "stakeholder", "standard", "state", "subject", "subsets", "succession", "terminate", "then",
+        "timeslice", "to", "transition", "until", "use", "variant", "variation", "verification", "verify",
+        "via", "view", "viewpoint", "when", "while", "xor"
+    ].reduce(f_wordify, {}),
+    types: [
+        "action", "allocation", "analysis", "attribute", "binding", "calc", "case", "comment", "concern",
+        "connection", "constraint", "def", "doc", "enum", "flow", "interface", "item", "metadata", "objective",
+        "occurrence", "package", "part", "port", "ref", "rendering", "rep", "requirement", "snapshot", "state",
+        "subject", "succession", "timeslice", "transition", "verification", "view", "viewpoint"
+    ].reduce(f_wordify, {}),
+    atoms: ['true', 'false', 'null'].reduce(f_wordify, {}),
+    number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
+    hooks: {
+        "'": function (stream) {
+            var b_escaped = false;
+            var s_next;
+            while (s_next = stream.next()) {
+                if (s_next === "'" && !b_escaped)
+                    break;
+                b_escaped = !b_escaped && s_next === '\\';
+            }
+            return 'variable';
+        },
+        '/': function (stream) {
+            if (stream.match('/*', false))
+                stream.next();
+            return false;
+        },
+        "#": function (stream) {
+            var b_first = true;
+            do {
+                if (stream.match("'", true)) {
                     var b_escaped = false;
-                    var s_next;
+                    var s_next = void 0;
                     while (s_next = stream.next()) {
                         if (s_next === "'" && !b_escaped)
                             break;
                         b_escaped = !b_escaped && s_next === '\\';
                     }
-                    return 'variable';
-                },
-                '/': function (stream) {
-                    if (stream.match('/*', false))
-                        stream.next();
-                    return false;
-                },
-                "#": function (stream) {
-                    var b_first = true;
-                    do {
-                        if (stream.match("'", true)) {
-                            var b_escaped = false;
-                            var s_next = void 0;
-                            while (s_next = stream.next()) {
-                                if (s_next === "'" && !b_escaped)
-                                    break;
-                                b_escaped = !b_escaped && s_next === '\\';
-                            }
-                        }
-                        else if (stream.match(/\w/, true)) {
-                            stream.eatWhile(/\w/);
-                        }
-                        else if (b_first) {
-                            return 'operator';
-                        }
-                        b_first = false;
-                    } while (stream.match('::', true));
-                    return 'keyword';
-                },
-            },
-        });
-    });
-    CodeMirror.defineMIME(P_MIME, SI_MODE);
-    CodeMirror.modeInfo.push({
-        ext: ['sysml'],
-        mime: P_MIME,
-        mode: SI_MODE,
-        name: 'sysml',
-    });
-}
-exports.defineSysMLv2Mode = defineSysMLv2Mode;
+                }
+                else if (stream.match(/\w/, true)) {
+                    stream.eatWhile(/\w/);
+                }
+                else if (b_first) {
+                    return 'operator';
+                }
+                b_first = false;
+            } while (stream.match('::', true));
+            return 'keyword';
+        },
+    },
+});

package/build/plugin.js

@@ -2,6 +2,8 @@
 /*
  * SysML 2 Pilot Implementation
  * Copyright (C) 2020  California Institute of Technology ("Caltech")
+ * Copyright (C) 2025  Model Driven Solutions, Inc.
+ * Copyright (C) 2025  Mgnite Inc.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -17,17 +19,71 @@
  *
  * @license LGPL-3.0-or-later <http://spdx.org/licenses/LGPL-3.0-or-later>
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+var codemirror_1 = require("@jupyterlab/codemirror");
 var mode_1 = require("./mode");
-function activate(app) {
-    mode_1.defineSysMLv2Mode();
-}
-/**
- * Initialization data for extension
- */
-var extension = {
-    activate: activate,
-    autoStart: true,
+var fold_1 = require("./fold");
+var plugin = {
     id: 'jupyterlab-sysml:plugin',
+    description: 'A JupyterLab extension adding a syntax highlight for SysMLv2 language.',
+    autoStart: true,
+    requires: [codemirror_1.IEditorLanguageRegistry, codemirror_1.IEditorExtensionRegistry],
+    activate: function (app, languages, ext) {
+        languages.addLanguage({
+            name: 'sysml',
+            displayName: 'sysml',
+            mime: 'text/x-sysml',
+            extensions: ['sysml'],
+            load: function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, codemirror_1.EditorLanguageRegistry.legacy(mode_1.sysmlparser)];
+                });
+            }); }
+        });
+        var sysmlFoldExtension = Object.freeze({
+            name: 'sysml-fold-extension',
+            default: true,
+            factory: function (options) {
+                return codemirror_1.EditorExtensionRegistry.createConditionalExtension((0, fold_1.sysmlFoldServiceSelection)(options));
+            }
+        });
+        ext.addExtension(sysmlFoldExtension);
+    }
 };
-exports.default = extension;
+exports.default = plugin;

package/package.json

@@ -1,36 +1,30 @@
 {
   "name": "@systems-modeling/jupyterlab-sysml",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "A JupyterLab extension for system modeling using SysML",
   "repository": "github:Systems-Modeling/SysML-v2-Pilot-Implementation",
   "author": "SysML v2 Submission Team",
   "license": "LGPL-3.0-or-later",
+  "main": "build/plugin.js",
   "keywords": [
     "jupyter",
     "jupyterlab",
     "jupyterlab-extension"
   ],
   "dependencies": {
-    "@jupyterlab/application": "3.x"
+    "@jupyterlab/application": "4.x"
   },
   "devDependencies": {
-    "@types/codemirror": "^0.0.98",
+    "@codemirror/legacy-modes": "^6.3.2",
+    "@jupyterlab/codemirror": ">=4.0",
     "@types/json-schema": "*",
-    "typescript": "<4.4.0"
-  },
-  "resolutions": {
-    "@lumino/coreutils": "^1.11.0",
-    "@lumino/widgets": "^1.37.2",
-    "lib0": "0.2.108"
-  },
-  "peerDependencies": {
-    "codemirror": "^5.58.1"
+    "typescript": "~5.8.3"
   },
   "files": [
     "build/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}"
   ],
   "jupyterlab": {
-    "extension": "build/plugin.js"
+    "extension": true
   },
   "scripts": {
     "build": "tsc",