pro-editor-schema 0.2.2 → 0.2.22

package/dist/index.js

@@ -25,6 +25,7 @@ __export(index_exports, {
   DEPENDENT_FORBIDDEN_ELEMENTS: () => DEPENDENT_FORBIDDEN_ELEMENTS,
   ELEMENT_SCHEMAS: () => ELEMENT_SCHEMAS,
   ELE_ID_ATTRIBUTE: () => ELE_ID_ATTRIBUTE,
+  ElementLabel: () => ElementLabel,
   FIGURE_PLACEMENT_ATTRIBUTE: () => FIGURE_PLACEMENT_ATTRIBUTE,
   ID_ATTRS: () => ID_ATTRS,
   IGNORED_ATTRIBUTES: () => IGNORED_ATTRIBUTES,
@@ -55,7 +56,6 @@ __export(index_exports, {
   findAttributeDefinitionByName: () => findAttributeDefinitionByName,
   findSchemaByCode: () => findSchemaByCode,
   findSchemaByElement: () => findSchemaByElement,
-  findSchemaByTagName: () => findSchemaByTagName,
   getAttributeName: () => getAttributeName,
   isAttributeRestricted: () => isAttributeRestricted,
   isIgnoredAttribute: () => isIgnoredAttribute,
@@ -67,24 +67,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/schema/utils/createSchema.ts
-var createSchema = ({
-  code,
-  kind,
-  tag,
-  requiredAttributes,
-  optionalAttributes,
-  defaultChildCode,
-  allowedChildrenCodes
-}) => {
-  return {
-    code,
-    kind,
-    tag,
-    requiredAttributes,
-    optionalAttributes,
-    defaultChildCode,
-    allowedChildrenCodes
-  };
+var createSchema = (params) => {
+  return params;
 };
 
 // src/schema/shared/globalAttributes.ts
@@ -143,11 +127,13 @@ var ATOM_CODES_ALLOWED_CHILDREN = [
   { code: "commentQuerySection", required: false },
   { code: "comment", required: false },
   { code: "query", required: false },
-  { code: "referenceMark", required: false }
+  { code: "referenceMark", required: false },
+  { code: "abbreviation", required: false }
 ];
 
 // src/schema/elementSchemas/atoms/atomTags.ts
 var B_TAG = "B";
+var ABBR_TAG = "ABBR";
 var I_TAG = "I";
 var U_TAG = "U";
 var SC_TAG = "SC";
@@ -185,6 +171,7 @@ var COMMENT_QUERY_SECTION_SCHEMA = createSchema({
   kind: "atom",
   tag: SPAN_TAG,
   code: "commentQuerySection",
+  matchesElement: (element) => element.classList.contains("cmtQurySection"),
   requiredAttributes: [...ID_ATTRS, "id"],
   optionalAttributes: [...TRACK_CHANGES_ATTRS, "title"],
   allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
@@ -204,6 +191,7 @@ var DELETION_SCHEMA = createSchema({
   code: "deletion",
   kind: "atom",
   tag: SPAN_TAG,
+  matchesElement: (element) => element.classList.contains("del"),
   requiredAttributes: [...TRACK_CHANGES_ATTRS, ...ID_ATTRS],
   optionalAttributes: [],
   allowedChildrenCodes: [
@@ -254,8 +242,15 @@ var INSERTION_SCHEMA = createSchema({
   code: "insertion",
   kind: "atom",
   tag: SPAN_TAG,
+  matchesElement: (element) => element.classList.contains("ins"),
   requiredAttributes: [...TRACK_CHANGES_ATTRS, ...ID_ATTRS],
-  optionalAttributes: [],
+  optionalAttributes: [
+    {
+      name: "role",
+      values: ["web-link", "figure-note-link", "figsource"],
+      defaultValue: ""
+    }
+  ],
   allowedChildrenCodes: [
     ...ATOM_CODES_ALLOWED_CHILDREN,
     ...INLINE_ELEMENT_CODES_ALLOWED_CHILDREN
@@ -549,6 +544,27 @@ var REFERENCE_MARK_SCHEMA = createSchema({
   allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
 });
 
+// src/schema/elementSchemas/atoms/abbr.ts
+var ABBR_SCHEMA = createSchema({
+  code: "abbreviation",
+  kind: "atom",
+  tag: ABBR_TAG,
+  requiredAttributes: [
+    ...ID_ATTRS,
+    "title",
+    TRACK_CHANGES_ATTR_DATA_TIME,
+    TRACK_CHANGES_ATTR_DATA_USERID,
+    TRACK_CHANGES_ATTR_DATA_USERNAME,
+    {
+      name: "data-abbr-action",
+      values: ["add", "edit"],
+      defaultValue: "add"
+    }
+  ],
+  optionalAttributes: [],
+  allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
+});
+
 // src/schema/elementSchemas/atoms/index.ts
 var ATOM_SCHEMAS = {
   indexterm: INDEXTERM_SCHEMA,
@@ -574,7 +590,8 @@ var ATOM_SCHEMAS = {
   content: CONTENT_SCHEMA,
   comment: COMMENT_SCHEMA,
   query: QUERY_SCHEMA,
-  reply: REPLY_SCHEMA
+  reply: REPLY_SCHEMA,
+  abbreviation: ABBR_SCHEMA
 };
 
 // src/schema/elementSchemas/elements/elementsTags.ts
@@ -1975,15 +1992,21 @@ var EPIGRAPH_SCHEMA = createSchema({
 });
 
 // src/schema/elementSchemas/elements/footnoteSection.ts
+var FOOTNOTE_SECTION_ROLES = ["ch", "bk"];
 var FOOTNOTE_SECTION_SCHEMA = createSchema({
   code: "footnoteSection",
   kind: "element",
   tag: SECTION_TAG,
+  matchesElement: (element) => {
+    const role = element.getAttribute("role");
+    if (role && FOOTNOTE_SECTION_ROLES.includes(role)) return true;
+    return element.querySelector(FOOTNOTE_TAG) !== null;
+  },
   requiredAttributes: [
     ...ID_ATTRS,
     {
       name: "role",
-      values: ["ch", "bk"],
+      values: FOOTNOTE_SECTION_ROLES,
       defaultValue: "ch"
     }
   ],
@@ -1996,16 +2019,22 @@ var FOOTNOTE_SECTION_SCHEMA = createSchema({
 });
 
 // src/schema/elementSchemas/elements/heading.ts
+var HEADING_ROLES = ["H1", "H2", "H3", "H4", "H5", "H6", "vignette_group"];
 var HEADING_SCHEMA = createSchema({
   code: "heading",
   kind: "element",
   tag: SECTION_TAG,
+  matchesElement: (element) => {
+    const role = element.getAttribute("role");
+    if (!role) return false;
+    return HEADING_ROLES.includes(role);
+  },
   requiredAttributes: [
     ...ID_ATTRS,
     "xmlid",
     {
       name: "role",
-      values: ["H1", "H2", "H3", "H4", "H5", "H6", "vignette_group"],
+      values: HEADING_ROLES,
       defaultValue: "H1"
     }
   ],
@@ -2073,7 +2102,6 @@ var MATHPHRASE_SCHEMA = createSchema({
   requiredAttributes: [ELE_ID_ATTRIBUTE],
   optionalAttributes: [],
   allowedChildrenCodes: [{ code: MATH_SCHEMA.code, required: true }]
-  // TODO: Should have flag for insertion and deletion
 });
 
 // src/schema/elementSchemas/elements/reference/bibliodiv.ts
@@ -2277,6 +2305,12 @@ var INLINEEQUATION_SCHEMA = createSchema({
 });
 
 // src/schema/elementSchemas/inlineElements/link.ts
+var TABLE_LINK_ROLE = "table";
+var FIGURE_LINK_ROLE = "figure";
+var EQUATION_LINK_ROLE = "equation";
+var FOOTNOTE_LINK_ROLE = "footnote";
+var REFERENCE_LINK_ROLE = "bibr";
+var CHAPTER_LINK_ROLE = "chapter";
 var LINK_SCHEMA = createSchema({
   code: "link",
   kind: "inline",
@@ -2284,14 +2318,20 @@ var LINK_SCHEMA = createSchema({
   requiredAttributes: [
     ...ID_ATTRS,
     "linkend",
-    "data-target-id",
     {
       name: "role",
-      values: ["table", "figure", "equation", "footnote", "bibr"],
-      defaultValue: ""
+      values: [
+        TABLE_LINK_ROLE,
+        FIGURE_LINK_ROLE,
+        EQUATION_LINK_ROLE,
+        FOOTNOTE_LINK_ROLE,
+        REFERENCE_LINK_ROLE,
+        CHAPTER_LINK_ROLE
+      ],
+      defaultValue: "bibr"
     }
   ],
-  optionalAttributes: [],
+  optionalAttributes: ["data-target-id"],
   allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
 });
 
@@ -2300,8 +2340,8 @@ var URI_SCHEMA = createSchema({
   code: "uri",
   kind: "inline",
   tag: URI_TAG,
-  requiredAttributes: [...ID_ATTRS],
-  optionalAttributes: ["linkend"],
+  requiredAttributes: [],
+  optionalAttributes: ["xlinkhref"],
   allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
 });
 
@@ -2371,42 +2411,11 @@ var isIgnoredAttribute = (attribute) => IGNORED_ATTRIBUTES.includes(attribute) |
 var isIgnoredElement = (element) => IGNORED_ELEMENT_SELECTORS.some((selector) => element.matches(selector));
 var isIgnoredValidation = (code) => IGNORED_VALIDATION_ELEMENT_SELECTORS.includes(code);
 var findSchemaByCode = (code) => SCHEMAS[code];
-var findSchemaByTagName = (tagName) => Object.values(SCHEMAS).filter(
-  (schema) => schema.tag === tagName.toUpperCase()
-);
 var findSchemaByElement = (element) => {
-  const tagName = element.tagName.toUpperCase();
-  const isInsertion = element.classList.contains("ins");
-  const isDeletion = element.classList.contains("del");
-  const isQueryComment = element.classList.contains("cmtQurySection");
-  const role = element.getAttribute("role");
-  if (tagName === SPAN_TAG) {
-    if (isQueryComment) {
-      return findSchemaByCode("commentQuerySection");
-    }
-    if (isInsertion) {
-      return findSchemaByCode("insertion");
-    }
-    if (isDeletion) {
-      return findSchemaByCode("deletion");
-    }
-  }
-  if (tagName === SECTION_TAG) {
-    if (role) {
-      if (role.startsWith("H")) {
-        return findSchemaByCode("heading");
-      }
-      if (role === "ch" || role === "bk") {
-        return findSchemaByCode("footnoteSection");
-      }
-    }
-    const isFootnoteSectionWithoutRole = element.querySelector(FOOTNOTE_TAG);
-    if (isFootnoteSectionWithoutRole) {
-      return findSchemaByCode("footnoteSection");
-    }
-  }
-  const candidates = findSchemaByTagName(tagName);
-  return candidates[0];
+  const schema = Object.values(SCHEMAS).find(
+    (schema2) => schema2.tag == element.tagName && (!schema2.matchesElement || schema2.matchesElement(element))
+  );
+  return schema;
 };
 var isAttributeRestricted = (attr) => typeof attr !== "string";
 var getAttributeName = (attribute) => typeof attribute === "string" ? attribute.toLowerCase() : attribute.name.toLowerCase();
@@ -2420,50 +2429,145 @@ var findAttributeDefinitionByName = (definitions, name) => {
 };
 
 // src/schema/utils/createElement.ts
-var validateAttributes = (attributes, schema) => {
-  const definitions = [
-    ...schema.requiredAttributes,
-    ...schema.optionalAttributes
-  ];
-  for (const [name, value] of Object.entries(attributes)) {
-    if (value === void 0) {
-      continue;
-    }
-    const definition = findAttributeDefinitionByName(definitions, name);
-    if (!definition) {
-      throw new Error(
-        `Invalid attribute "${name}" for schema "${schema.code}".`
-      );
-    }
-    if (!isAttributeRestricted(definition)) {
-      continue;
-    }
-    if (!definition.values.includes(value)) {
-      throw new Error(
-        `Invalid value "${value}" for attribute "${name}" on schema "${schema.code}". Allowed values: ${definition.values.join(", ")}.`
-      );
-    }
-  }
-};
 var createElement = ({
   schemaCode,
   attributes
 }) => {
   const schema = findSchemaByCode(schemaCode);
-  if (!schema) {
-    throw new Error(`Schema not found for code: ${schemaCode}`);
-  }
-  validateAttributes(attributes, schema);
   const element = document.createElement(schema.tag.toLowerCase());
   for (const [name, value] of Object.entries(attributes)) {
-    if (value === void 0) {
-      continue;
-    }
+    if (!value) continue;
     element.setAttribute(name, String(value));
   }
   return element;
 };
 
+// src/schema/shared/labelElements.ts
+var ElementLabel = {
+  referenceBibliomixed: "Reference Bibliomixed",
+  referenceBibliography: "Reference Bibliography",
+  bibliodiv: "Bibliodiv",
+  indexterm: "Indexterm",
+  primary: "Primary",
+  secondary: "Secondary",
+  tertiary: "Tertiary",
+  quaternary: "Quaternary",
+  bookmark: "Bookmark",
+  see: "Cross Reference",
+  commentQuerySection: "Comment/Query",
+  comment: "Comment",
+  content: "Content",
+  query: "Query",
+  reply: "Reply",
+  deletion: "Deletion",
+  emphasis: "Emphasis",
+  highlightmark: "Highlightmark",
+  i: "Italic",
+  insertion: "Insertion",
+  sc: "Small Caps",
+  strike: "Strike",
+  sub: "Subscript",
+  sup: "Superscript",
+  u: "Underline",
+  b: "Bold",
+  referenceMark: "Reference Mark",
+  degrees: "Degrees",
+  email: "Email",
+  equation: "Equation",
+  fignote: "Fignote",
+  figsource: "Figsource",
+  firstname: "Firstname",
+  footnote: "Footnote Marker",
+  footnoteno: "Footnote Number",
+  honorific: "Honorific",
+  img: "Image",
+  informalfigure: "Floating Figure",
+  keyword: "Keyword",
+  label1: "Label",
+  li: "List Item",
+  line: "Line",
+  lrh: "Running Head Left",
+  math: "Math",
+  mathphrase: "Math Phrase",
+  merror: "Math Error",
+  mfrac: "Math  Fraction",
+  mi: "Math Identifier",
+  mmultiscripts: "Math Multiscripts",
+  mn: "Math Number",
+  mo: "Math Operator",
+  mover: "Math Over",
+  mpadded: "Math Padded",
+  mphantom: "Math Phantom",
+  mprescripts: "Math Prescripts",
+  mroot: "Math Root",
+  mrow: "Math Row",
+  ms: "Math Space",
+  mspace: "Math Space",
+  msqrt: "Math Square Root",
+  mstyle: "Math Style",
+  msub: "Math Subscript",
+  msubsup: "Math Subscript Superscript",
+  msup: "Math Superscript",
+  mtable: "Math Table",
+  mtd: "Math Table Data",
+  mtext: "Math Text",
+  mtr: "Math Table Row",
+  munder: "Math Under",
+  munderover: "Math Under Over",
+  olink: "Online Link",
+  org: "Org",
+  orgname: "Orgname",
+  para: "Paragraph",
+  punc: "Punctuation",
+  rrh: "Running Head Right",
+  source1: "Source",
+  speaker: "Speaker",
+  subtitle1: "Subtitle",
+  surname: "Surname",
+  tag: "Tag",
+  tblfn: "Table Footnote",
+  tblsource: "Table Source",
+  thead: "Thead",
+  title1: "Title",
+  token: "Token",
+  tp: "Table Paragraph",
+  abstract1: "Abstract",
+  affiliation: "Affiliation",
+  alttext: "Alttext",
+  appendix: "Appendix",
+  author: "Author",
+  authorgroup: "Authorgroup",
+  blockquote: "Blockquote",
+  caption1: "Caption",
+  chapter: "Chapter",
+  dialogue: "Dialogue",
+  epigraph: "Epigraph",
+  figure1: "Figure",
+  footnoteSection: "Footnote Section",
+  heading: "Heading",
+  imageobject: "Image Object",
+  info1: "Info",
+  keywordset: "Keyword FGroup",
+  mediaobject: "Mediaobject",
+  ol: "Ordered List",
+  personname: "Person Name",
+  poem: "Poem",
+  sidebar: "Box",
+  table: "Table",
+  table1: "Table",
+  tbody: "Table Body",
+  td: "Table Data",
+  tgroup: "Table Group",
+  tr: "Table Row",
+  ul: "Unordered List",
+  footnote1: "Footnote",
+  inlineequation: "Inline Equation",
+  link: "Link",
+  uri: "URI",
+  phrase: "Phrase",
+  abbreviation: "Abbreviation"
+};
+
 // src/schema/shared/dependentsForbiddenElements.ts
 var DEPENDENT_FORBIDDEN_ELEMENTS = [
   {
@@ -2503,6 +2607,25 @@ var retrieveTextIgnoringNodesWithSelector = (element, selector = ".del") => {
   return clonedElement.textContent || "";
 };
 
+// src/validation/utils/getElementsSelector.ts
+var getElementsSelector = ({
+  element,
+  selector,
+  filterDeletedNodes
+}) => {
+  const elements = element.querySelectorAll(selector);
+  if (filterDeletedNodes) {
+    return Array.from(elements).filter((element2) => {
+      const hasDeletedParent = element2.closest(".del") !== null;
+      if (hasDeletedParent) {
+        return false;
+      }
+      return true;
+    });
+  }
+  return Array.from(elements);
+};
+
 // src/validation/validateFootnotes.ts
 var extractFootnoteNumber = (footnote) => {
   if (!footnote) return "no label";
@@ -2545,7 +2668,11 @@ var validateFootnoteCue = (footnoteElement, root) => {
   return errors;
 };
 var validateConsecutiveFootnotes = (root) => {
-  const footnotes = Array.from(root.querySelectorAll(FOOTNOTE_SCHEMA.tag));
+  const footnotes = getElementsSelector({
+    element: root,
+    selector: FOOTNOTE_SCHEMA.tag,
+    filterDeletedNodes: true
+  });
   if (footnotes.length === 0) {
     return [];
   }
@@ -2574,9 +2701,11 @@ var validateConsecutiveFootnotes = (root) => {
   return [];
 };
 var validateConsecutiveFootnoteCues = (root) => {
-  const footnoteLinks = Array.from(
-    root.querySelectorAll(FOOTNOTE_LINK_SCHEMA.tag)
-  );
+  const footnoteLinks = getElementsSelector({
+    element: root,
+    selector: FOOTNOTE_LINK_SCHEMA.tag,
+    filterDeletedNodes: true
+  });
   if (footnoteLinks.length === 0) {
     return [];
   }
@@ -2603,6 +2732,13 @@ var validateConsecutiveFootnoteCues = (root) => {
 var findElementLinkedTo = (linkend, elementsToLink) => {
   return elementsToLink.includes(linkend);
 };
+var LINK_BLOCKER_ROLES = [
+  TABLE_LINK_ROLE,
+  FIGURE_LINK_ROLE,
+  EQUATION_LINK_ROLE,
+  FOOTNOTE_LINK_ROLE,
+  CHAPTER_LINK_ROLE
+];
 var validateLinkend = (linkElement, elementsToLink) => {
   const linkend = linkElement.getAttribute("linkend");
   if (!linkend) {
@@ -2623,22 +2759,27 @@ var validateLinkend = (linkElement, elementsToLink) => {
       })
     ];
   }
+  const role = linkElement.getAttribute("role");
+  if (!role) {
+    return [];
+  }
   if (findElementLinkedTo(linkend, elementsToLink)) {
     return [];
   }
+  const isBlocker = LINK_BLOCKER_ROLES.includes(role.toLowerCase());
   return [
     createValidationIssue({
       store: getStore(linkElement),
       title: "Unlinked element",
       kind: "unlinked",
-      description: "This link is not referenced to any element in the current chapter or reference chapters. Please link it again manually.",
-      level: "blocker"
+      description: "This link is not referenced to any element in the current chapter or any other chapter. Please link it again manually.",
+      level: isBlocker ? "blocker" : "warning"
     })
   ];
 };
 
 // src/validation/validateAttributes.ts
-var validateAttributes2 = (element, schema) => {
+var validateAttributes = (element, schema) => {
   const errors = [];
   const definitions = [
     ...schema.requiredAttributes,
@@ -2666,8 +2807,8 @@ var validateAttributes2 = (element, schema) => {
     }
     if (!definition.values.includes(value)) {
       addValidationIssue(errors, {
-        store: element.id,
-        title: `Invalid attribute value "${value}"`,
+        store: getStore(element),
+        title: `Invalid attribute value "${value}" in element ${element.tagName}`,
         level: "warning",
         kind: "forbidden",
         description: `The attribute "${name}" has an invalid value "${value}".`
@@ -2689,7 +2830,7 @@ var validateElementAgainstSchema = (element, schema) => {
       description: `The element is not allowed in this context.`
     });
   }
-  errors.push(...validateAttributes2(element, schema));
+  errors.push(...validateAttributes(element, schema));
   errors.push(...validateChildren(element, schema));
   return errors;
 };
@@ -2704,7 +2845,7 @@ var validateRequiredChildren = (element, schema, childElements) => {
       return childSchema?.code === allowedChild.code;
     });
     if (!hasChild) {
-      const requiredChildrenTag = findSchemaByCode(allowedChild.code)?.tag || allowedChild.code;
+      const requiredChildrenTag = findSchemaByCode(allowedChild.code).tag;
       addValidationIssue(errors, {
         store: getStore(element),
         title: `Missing required child element ${requiredChildrenTag}`,
@@ -2801,7 +2942,34 @@ var validateReferenceCited = (referenceElement, linkElements) => {
       title: "Unlinked element",
       kind: "unlinked",
       description: "This reference is not cited in this chapter or any other chapter. Please add a link to this reference or delete the reference.",
-      level: "blocker"
+      level: "warning"
+    })
+  ];
+};
+
+// src/validation/validateUri.ts
+var WEB_URI_REGEX = /^(?:(?:https?):\/\/)?(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}(?::\d{1,5})?(?:\/[^\s]*)?$/i;
+var isValidUri = (uri) => {
+  if (!uri || /\s/.test(uri)) {
+    return false;
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(uri) && !/^https?:\/\//i.test(uri)) {
+    return false;
+  }
+  return WEB_URI_REGEX.test(uri);
+};
+var validateUri = (uriElement) => {
+  const url = uriElement.textContent.trim();
+  if (isValidUri(url)) {
+    return [];
+  }
+  return [
+    createValidationIssue({
+      store: getStore(uriElement),
+      title: "URL cannot be reached",
+      kind: "unlinked",
+      description: "URL cannot be reached. Please check and adjust.",
+      level: "warning"
     })
   ];
 };
@@ -2828,6 +2996,9 @@ var validateElement = (element, root, elementsToLink, linkElements, schemasToVal
     if (schema.tag === FOOTNOTE_SCHEMA.tag) {
       errors.push(...validateFootnoteCue(element, root));
     }
+    if (schema.tag === URI_SCHEMA.tag) {
+      errors.push(...validateUri(element));
+    }
     if (isIgnoredValidation(schema.code)) {
       return errors;
     }
@@ -2869,6 +3040,7 @@ var validateXml = (xml, elementsToLink, linkElements, schemasToValidateAgainst)
   DEPENDENT_FORBIDDEN_ELEMENTS,
   ELEMENT_SCHEMAS,
   ELE_ID_ATTRIBUTE,
+  ElementLabel,
   FIGURE_PLACEMENT_ATTRIBUTE,
   ID_ATTRS,
   IGNORED_ATTRIBUTES,
@@ -2899,7 +3071,6 @@ var validateXml = (xml, elementsToLink, linkElements, schemasToValidateAgainst)
   findAttributeDefinitionByName,
   findSchemaByCode,
   findSchemaByElement,
-  findSchemaByTagName,
   getAttributeName,
   isAttributeRestricted,
   isIgnoredAttribute,