@ni/nimble-components 34.6.1 → 34.6.5

package/dist/all-components-bundle.js

@@ -41441,6 +41441,7 @@ so this becomes the fallback color for the slot */ ''}
     setMeta: () => setMeta,
     setNode: () => setNode,
     setNodeSelection: () => setNodeSelection,
+    setTextDirection: () => setTextDirection,
     setTextSelection: () => setTextSelection,
     sinkListItem: () => sinkListItem,
     splitBlock: () => splitBlock,
@@ -41452,6 +41453,7 @@ so this becomes the fallback color for the slot */ ''}
     undoInputRule: () => undoInputRule,
     unsetAllMarks: () => unsetAllMarks,
     unsetMark: () => unsetMark,
+    unsetTextDirection: () => unsetTextDirection,
     updateAttributes: () => updateAttributes,
     wrapIn: () => wrapIn,
     wrapInList: () => wrapInList
@@ -42227,23 +42229,28 @@ so this becomes the fallback color for the slot */ ''}
     if (schemaType === "mark") {
       markType = getMarkType(typeOrName, state.schema);
     }
-    if (dispatch) {
-      tr.selection.ranges.forEach((range) => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-          if (nodeType && nodeType === node.type) {
+    let canReset = false;
+    tr.selection.ranges.forEach((range) => {
+      state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+        if (nodeType && nodeType === node.type) {
+          canReset = true;
+          if (dispatch) {
             tr.setNodeMarkup(pos, void 0, deleteProps(node.attrs, attributes));
           }
-          if (markType && node.marks.length) {
-            node.marks.forEach((mark) => {
-              if (markType === mark.type) {
+        }
+        if (markType && node.marks.length) {
+          node.marks.forEach((mark) => {
+            if (markType === mark.type) {
+              canReset = true;
+              if (dispatch) {
                 tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
               }
-            });
-          }
-        });
+            }
+          });
+        }
       });
-    }
-    return true;
+    });
+    return canReset;
   };
 
   // src/commands/scrollIntoView.ts
@@ -42639,12 +42646,12 @@ so this becomes the fallback color for the slot */ ''}
     );
   }
   function buildAttributeSpec(extensionAttribute) {
-    var _a, _b, _c;
+    var _a, _b;
     const spec = {};
-    if (!((_a = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _a.isRequired) && ((_b = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _b.default) !== void 0) {
+    if (!((_a = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _a.isRequired) && "default" in ((extensionAttribute == null ? void 0 : extensionAttribute.attribute) || {})) {
       spec.default = extensionAttribute.attribute.default;
     }
-    if (((_c = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _c.validate) !== void 0) {
+    if (((_b = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _b.validate) !== void 0) {
       spec.validate = extensionAttribute.attribute.validate;
     }
     return [extensionAttribute.name, spec];
@@ -43282,6 +43289,35 @@ so this becomes the fallback color for the slot */ ''}
     }
     return true;
   };
+
+  // src/commands/setTextDirection.ts
+  var setTextDirection = (direction, position) => ({ tr, state, dispatch }) => {
+    const { selection } = state;
+    let from;
+    let to;
+    if (typeof position === "number") {
+      from = position;
+      to = position;
+    } else if (position && "from" in position && "to" in position) {
+      from = position.from;
+      to = position.to;
+    } else {
+      from = selection.from;
+      to = selection.to;
+    }
+    if (dispatch) {
+      tr.doc.nodesBetween(from, to, (node, pos) => {
+        if (node.isText) {
+          return;
+        }
+        tr.setNodeMarkup(pos, void 0, {
+          ...node.attrs,
+          dir: direction
+        });
+      });
+    }
+    return true;
+  };
   var setTextSelection = (position) => ({ tr, dispatch }) => {
     if (dispatch) {
       const { doc } = tr;
@@ -43628,6 +43664,34 @@ so this becomes the fallback color for the slot */ ''}
     return true;
   };
 
+  // src/commands/unsetTextDirection.ts
+  var unsetTextDirection = (position) => ({ tr, state, dispatch }) => {
+    const { selection } = state;
+    let from;
+    let to;
+    if (typeof position === "number") {
+      from = position;
+      to = position;
+    } else if (position && "from" in position && "to" in position) {
+      from = position.from;
+      to = position.to;
+    } else {
+      from = selection.from;
+      to = selection.to;
+    }
+    if (dispatch) {
+      tr.doc.nodesBetween(from, to, (node, pos) => {
+        if (node.isText) {
+          return;
+        }
+        const newAttrs = { ...node.attrs };
+        delete newAttrs.dir;
+        tr.setNodeMarkup(pos, void 0, newAttrs);
+      });
+    }
+    return true;
+  };
+
   // src/commands/updateAttributes.ts
   var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
     let nodeType = null;
@@ -43645,41 +43709,48 @@ so this becomes the fallback color for the slot */ ''}
     if (schemaType === "mark") {
       markType = getMarkType(typeOrName, state.schema);
     }
-    if (dispatch) {
-      tr.selection.ranges.forEach((range) => {
-        const from = range.$from.pos;
-        const to = range.$to.pos;
-        let lastPos;
-        let lastNode;
-        let trimmedFrom;
-        let trimmedTo;
-        if (tr.selection.empty) {
-          state.doc.nodesBetween(from, to, (node, pos) => {
+    let canUpdate = false;
+    tr.selection.ranges.forEach((range) => {
+      const from = range.$from.pos;
+      const to = range.$to.pos;
+      let lastPos;
+      let lastNode;
+      let trimmedFrom;
+      let trimmedTo;
+      if (tr.selection.empty) {
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (nodeType && nodeType === node.type) {
+            canUpdate = true;
+            trimmedFrom = Math.max(pos, from);
+            trimmedTo = Math.min(pos + node.nodeSize, to);
+            lastPos = pos;
+            lastNode = node;
+          }
+        });
+      } else {
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (pos < from && nodeType && nodeType === node.type) {
+            canUpdate = true;
+            trimmedFrom = Math.max(pos, from);
+            trimmedTo = Math.min(pos + node.nodeSize, to);
+            lastPos = pos;
+            lastNode = node;
+          }
+          if (pos >= from && pos <= to) {
             if (nodeType && nodeType === node.type) {
-              trimmedFrom = Math.max(pos, from);
-              trimmedTo = Math.min(pos + node.nodeSize, to);
-              lastPos = pos;
-              lastNode = node;
-            }
-          });
-        } else {
-          state.doc.nodesBetween(from, to, (node, pos) => {
-            if (pos < from && nodeType && nodeType === node.type) {
-              trimmedFrom = Math.max(pos, from);
-              trimmedTo = Math.min(pos + node.nodeSize, to);
-              lastPos = pos;
-              lastNode = node;
-            }
-            if (pos >= from && pos <= to) {
-              if (nodeType && nodeType === node.type) {
+              canUpdate = true;
+              if (dispatch) {
                 tr.setNodeMarkup(pos, void 0, {
                   ...node.attrs,
                   ...attributes
                 });
               }
-              if (markType && node.marks.length) {
-                node.marks.forEach((mark) => {
-                  if (markType === mark.type) {
+            }
+            if (markType && node.marks.length) {
+              node.marks.forEach((mark) => {
+                if (markType === mark.type) {
+                  canUpdate = true;
+                  if (dispatch) {
                     const trimmedFrom2 = Math.max(pos, from);
                     const trimmedTo2 = Math.min(pos + node.nodeSize, to);
                     tr.addMark(
@@ -43691,36 +43762,36 @@ so this becomes the fallback color for the slot */ ''}
                       })
                     );
                   }
-                });
-              }
+                }
+              });
             }
+          }
+        });
+      }
+      if (lastNode) {
+        if (lastPos !== void 0 && dispatch) {
+          tr.setNodeMarkup(lastPos, void 0, {
+            ...lastNode.attrs,
+            ...attributes
           });
         }
-        if (lastNode) {
-          if (lastPos !== void 0) {
-            tr.setNodeMarkup(lastPos, void 0, {
-              ...lastNode.attrs,
-              ...attributes
-            });
-          }
-          if (markType && lastNode.marks.length) {
-            lastNode.marks.forEach((mark) => {
-              if (markType === mark.type) {
-                tr.addMark(
-                  trimmedFrom,
-                  trimmedTo,
-                  markType.create({
-                    ...mark.attrs,
-                    ...attributes
-                  })
-                );
-              }
-            });
-          }
+        if (markType && lastNode.marks.length) {
+          lastNode.marks.forEach((mark) => {
+            if (markType === mark.type && dispatch) {
+              tr.addMark(
+                trimmedFrom,
+                trimmedTo,
+                markType.create({
+                  ...mark.attrs,
+                  ...attributes
+                })
+              );
+            }
+          });
         }
-      });
-    }
-    return true;
+      }
+    });
+    return canUpdate;
   };
   var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
@@ -44576,6 +44647,7 @@ so this becomes the fallback color for the slot */ ''}
     Keymap: () => Keymap,
     Paste: () => Paste,
     Tabindex: () => Tabindex,
+    TextDirection: () => TextDirection,
     focusEventsPluginKey: () => focusEventsPluginKey
   });
 
@@ -44920,6 +44992,63 @@ so this becomes the fallback color for the slot */ ''}
       ];
     }
   });
+  var TextDirection = Extension.create({
+    name: "textDirection",
+    addOptions() {
+      return {
+        direction: void 0
+      };
+    },
+    addGlobalAttributes() {
+      if (!this.options.direction) {
+        return [];
+      }
+      const { nodeExtensions } = splitExtensions(this.extensions);
+      return [
+        {
+          types: nodeExtensions.filter((extension) => extension.name !== "text").map((extension) => extension.name),
+          attributes: {
+            dir: {
+              default: this.options.direction,
+              parseHTML: (element) => {
+                const dir = element.getAttribute("dir");
+                if (dir && (dir === "ltr" || dir === "rtl" || dir === "auto")) {
+                  return dir;
+                }
+                return this.options.direction;
+              },
+              renderHTML: (attributes) => {
+                if (!attributes.dir) {
+                  return {};
+                }
+                return {
+                  dir: attributes.dir
+                };
+              }
+            }
+          }
+        }
+      ];
+    },
+    addProseMirrorPlugins() {
+      return [
+        new Plugin({
+          key: new PluginKey("textDirection"),
+          props: {
+            attributes: () => {
+              const direction = this.options.direction;
+              if (!direction) {
+                return {};
+              }
+              return {
+                dir: direction
+              };
+            }
+          }
+        })
+      ];
+    }
+  });
 
   // src/NodePos.ts
   var NodePos = class _NodePos {
@@ -45212,6 +45341,7 @@ img.ProseMirror-separator {
         extensions: [],
         autofocus: false,
         editable: true,
+        textDirection: void 0,
         editorProps: {},
         parseOptions: {},
         coreExtensionOptions: {},
@@ -45489,7 +45619,10 @@ img.ProseMirror-separator {
         Tabindex,
         Drop,
         Paste,
-        Delete
+        Delete,
+        TextDirection.configure({
+          direction: this.options.textDirection
+        })
       ].filter((ext) => {
         if (typeof this.options.enableCoreExtensions === "object") {
           return this.options.enableCoreExtensions[ext.name] !== false;
@@ -46216,6 +46349,8 @@ ${renderedContent}
           break;
         } else if (currentLine.trim() === "") {
           i += 1;
+          totalRaw = `${totalRaw}${currentLine}
+`;
           continue;
         } else {
           return void 0;
@@ -46276,7 +46411,7 @@ ${renderedContent}
     }
     return {
       items,
-      raw: totalRaw.trim()
+      raw: totalRaw
     };
   }
 
@@ -62324,7 +62459,7 @@ ${nextLine.slice(indentLevel + 2)}`;
     addProseMirrorPlugins() {
       var _a;
       const plugin = new PluginKey(this.name);
-      const defaultNode = ((_a = this.editor.schema.topNodeType.contentMatch.defaultType) == null ? void 0 : _a.name) || this.options.node || "paragraph";
+      const defaultNode = this.options.node || ((_a = this.editor.schema.topNodeType.contentMatch.defaultType) == null ? void 0 : _a.name) || "paragraph";
       const disabledNodes = Object.entries(this.editor.schema.nodes).map(([, value]) => value).filter((node) => (this.options.notAfter || []).concat(defaultNode).includes(node.name));
       return [
         new Plugin({
@@ -69945,6 +70080,11 @@ focus outline in that case.
       /** @internal */
       onCellActionMenuToggle(event, column) {
           this.menuOpen = event.detail.newState;
+          // Workaround for Firefox issue when action menus opened on different rows
+          // See: https://github.com/ni/nimble/issues/2744
+          if (!event.detail.newState) {
+              this.currentActionMenuColumn = undefined;
+          }
           this.emitActionMenuToggleEvent('row-action-menu-toggle', event.detail, column);
       }
       /** @internal */