highmark-occam 1.0.1

package/license.txt

@@ -0,0 +1,48 @@
+MIT And Anti-996 Licenses
+
+Copyright (c) 2023 James Smith
+
+These licenses shall be included in all copies or substantial portions of
+this software and associated documentation files (the "Software").
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this 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:
+
+1. The individual or the legal entity must conspicuously display,
+without modification, this License and the notice on each redistributed
+or derivative copy of the Licensed Work.
+
+2. The individual or the legal entity must strictly comply with all
+applicable laws, regulations, rules and standards of the jurisdiction
+relating to labor and employment where the individual is physically
+located or where the individual was born or naturalized; or where the
+legal entity is registered or is operating (whichever is stricter). In
+case that the jurisdiction has no such laws, regulations, rules and
+standards or its laws, regulations, rules and standards are
+unenforceable, the individual or the legal entity are required to
+comply with Core International Labor Standards.
+
+3. The individual or the legal entity shall not induce, suggest or force
+its employee(s), whether full-time or part-time, or its independent
+contractor(s), in any methods, to agree in oral or written form, to
+directly or indirectly restrict, weaken or relinquish his or her
+rights or remedies under such laws, regulations, rules and standards
+relating to labor and employment as mentioned above, no matter whether
+such written or oral agreements are enforceable under the laws of the
+said jurisdiction, nor shall such individual or the legal entity
+limit, in any methods, the rights of its employee(s) or independent
+contractor(s) from reporting or complaining to the copyright holder or
+relevant authorities monitoring the compliance of the license about
+its violation(s) of the said license.
+
+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/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "highmark-occam",
+  "author": "James Smith",
+  "version": "1.0.1",
+  "license": "MIT, Anti-996",
+  "homepage": "https://github.com/djalbat/highmark-occam",
+  "description": "Highmark support for Occam.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/djalbat/highmark-occam"
+  },
+  "dependencies": {
+    "easy": "^24.1.8",
+    "highmark-markdown": "^1.2.93",
+    "occam-custom-grammars": "^6.0.36",
+    "occam-grammars": "^1.3.529",
+    "occam-lexers": "^23.1.48",
+    "occam-nominal": "^1.0.115",
+    "occam-parsers": "^23.1.54",
+    "occam-query": "^4.1.159",
+    "occam-styles": "^5.0.453",
+    "yapp": "^5.1.305"
+  },
+  "devDependencies": {
+    "@swc/core": "1.13.20",
+    "easy-layout": "^6.0.301",
+    "easy-with-style": "^3.0.549",
+    "esbuild": "0.11.14",
+    "express": "^4.17.1",
+    "juxtapose": "^4.0.136",
+    "lively-cli": "^2.0.98",
+    "watchful-cli": "^1.7.89"
+  },
+  "scripts": {
+    "start": "node ./bin/main.js",
+    "clean": "rm -rf ./lib",
+    "watchful": "watchful -m --transpiler=swc --bundler=esbuild --source-directory=./src --lib-directory=./lib --entry-file=example.js --bundle-file=./example.js --wait=100",
+    "batch": "npm run watchful batch --",
+    "batch-debug": "npm run watchful batch -- --debug",
+    "incremental": "npm run watchful incremental --",
+    "incremental-debug": "npm run watchful incremental -- --debug",
+    "build": "npm run clean && npm run batch",
+    "build-debug": "npm run clean && npm run batch-debug",
+    "watch": "npm run clean && npm run batch && npm run incremental",
+    "watch-debug": "npm run clean && npm run batch-debug && npm run incremental-debug"
+  },
+  "files": [
+    "src",
+    "lib"
+  ],
+  "main": "./lib/index.js"
+}

package/src/blockListing.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import PrettyPrinter from "./prettyPrinter";
+
+import { domUtilities } from "highmark-markdown";
+import { elementUtilities } from "easy";
+
+const { mountElement, unmountElement } = elementUtilities,
+      { remove, insertAfter, insertBeforehand } = domUtilities;
+
+export default class BlockListing extends PrettyPrinter {
+  mount(parentDOMElement, siblingDOMElement, context) {
+    const domElement = this.getDOMElement();
+
+    (siblingDOMElement !== null) ?
+      insertAfter(domElement, parentDOMElement, siblingDOMElement) :
+        insertBeforehand(domElement, parentDOMElement);
+
+    const element = this; ///
+
+    mountElement(element);
+
+    siblingDOMElement = domElement;  ///
+
+    return siblingDOMElement;
+  }
+
+  unmount(parentDOMElement, context) {
+    const element = this; ///
+
+    unmountElement(element);
+
+    const domElement = this.getDOMElement();
+
+    remove(domElement, parentDOMElement);
+  }
+
+  static fromClass(properties, ...remainingArgumments) { return PrettyPrinter.fromClass(BlockListing, properties, ...remainingArgumments) ; }
+}

package/src/constants.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export const EMPTY_STRING = "";

package/src/div/container.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import withStyle from "easy-with-style";
+
+import { Element } from "easy";
+import { editorScheme } from "occam-styles";
+
+import PrettyPrinter from "../prettyPrinter";
+
+const { borderColour } = editorScheme;
+
+class ContainerDiv extends Element {
+  childElements() {
+    const { changeCustomHandler } = this.properties;
+
+    return ([
+
+      <PrettyPrinter changeCustomHandler={changeCustomHandler} />
+
+    ]);
+  }
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "container"
+  };
+}
+
+export default withStyle(ContainerDiv)`
+
+  width: 100%;
+  height: 100%;
+  border: 1px solid ${borderColour};
+  position: relative;
+
+`;

package/src/div/line.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+
+import SyntaxDiv from "../div/syntax";
+
+class LineDiv extends Element {
+  getHTML() {
+    const { html } = this.properties;
+
+    return html
+  }
+
+  childElements() {
+    const html = this.getHTML();
+
+    return ([
+
+      <SyntaxDiv html={html} />
+
+    ]);
+  }
+
+  static tagName = "div";
+
+  static ignoredProperties = [
+    "html"
+  ];
+
+  static defaultProperties = {
+    className: "line"
+  };
+}
+
+export default withStyle(LineDiv)`
+
+  font-size: inherit;
+  line-height: inherit;
+  font-family: inherit;
+    
+`;

package/src/div/lines.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+
+import LineDiv from "../div/line";
+
+class LinesDiv extends Element {
+  getDocument() {
+    const { document } = this.properties;
+
+    return document;
+  }
+
+  didMount() {
+    const document = this.getDocument(),
+          documentType = document.getType(),
+          documentTypeClass = documentType; ///
+
+    this.addClass(documentTypeClass);
+  }
+
+  willUnmount() {
+    ///
+  }
+
+  childElements() {
+    const document = this.getDocument(),
+          lines = document.getLines(),
+          lineDivs = lines.map((line) => {
+            const html = document.lineAsHTML(line),
+                  lineDiv =
+
+                    <LineDiv html={html} />
+
+                  ;
+
+            return lineDiv;
+          }),
+          childElements = lineDivs; ///
+
+    return childElements;
+  }
+
+  static tagName = "div";
+
+  static ignoredProperties = [
+    "document"
+  ];
+
+  static defaultProperties = {
+    className: "lines",
+    spellCheck: "false"
+  };
+}
+
+export default withStyle(LinesDiv)`
+
+  outline: none;
+  display: grid;
+  min-width: 100%;
+  
+  font-size: inherit;
+  line-height: inherit;
+  font-family: inherit;
+
+`;

package/src/div/syntax.js

@@ -0,0 +1,45 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+
+class SyntaxDiv extends Element {
+  getHTML() {
+    const { html } = this.properties;
+
+    return html
+  }
+
+  didMount() {
+    const html = this.getHTML();
+
+    this.html(html);
+  }
+
+  willUnmount() {
+    ///
+  }
+
+  static tagName = "div";
+
+  static ignoredProperties = [
+    "html"
+  ];
+
+  static defaultProperties = {
+    className: "syntax"
+  };
+}
+
+export default withStyle(SyntaxDiv)`
+
+  display: inline;
+  white-space: pre;
+  
+  font-size: inherit;
+  line-height: inherit;
+  font-family: inherit;
+  
+    
+`;

package/src/document/bnf.js

@@ -0,0 +1,27 @@
+"use strict";
+
+import { BNFLexer } from "occam-lexers";
+import { BNFParser } from "occam-parsers";
+
+import Document from "../document";
+import ErrorOverlayToken from "../token/overlay/common/error";
+
+import { BNF_DOCUMENT_TYPE } from "../documentTypes";
+
+const bnfLexer = BNFLexer.fromNothing(),
+      bnfParser = BNFParser.fromNothing();
+
+export default class BNFDocument extends Document {
+  static overlayTokenMap = {
+    "//error": ErrorOverlayToken
+  };
+
+  static fromContent(content) {
+    const type = BNF_DOCUMENT_TYPE,
+          lexer = bnfLexer,  ///
+          parser = bnfParser,  ///
+          bnfDocument = Document.fromContentTypeLexerAndParser(BNFDocument, content, type, lexer, parser);
+
+    return bnfDocument;
+  }
+}

package/src/document/furtle.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import { FurtleLexer, FurtleParser } from "occam-grammars";
+
+import Document from "../document";
+import ErrorOverlayToken from "../token/overlay/common/error";
+import NonsenseOverlayToken from "../token/overlay/common/nonsense";
+import LabelNameOverlayToken from "../token/overlay/common/labelName";
+import ReferenceNameOverlayToken from "../token/overlay/common/referenceName";
+
+import { FURTLE_DOCUMENT_TYPE } from "../documentTypes";
+
+const furtleLexer = FurtleLexer.fromNothing(),
+      furtleParser = FurtleParser.fromNothing();
+
+export default class FurtleDocument extends Document {
+  static overlayTokenMap = {
+    "//error": ErrorOverlayToken,
+    "//nonsense": NonsenseOverlayToken,
+    "//label/@name": LabelNameOverlayToken,
+    "//reference/@name": ReferenceNameOverlayToken
+  };
+
+  static fromContent(content) {
+    const type = FURTLE_DOCUMENT_TYPE,
+          lexer = furtleLexer,  ///
+          parser = furtleParser,  ///
+          furtleDocument = Document.fromContentTypeLexerAndParser(FurtleDocument, content, type, lexer, parser);
+
+    return furtleDocument;
+  }
+}

package/src/document/json.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { JSONLexer, JSONParser } from "occam-grammars";
+
+import Document from "../document";
+import ErrorOverlayToken from "../token/overlay/common/error";
+import NonsenseOverlayToken from "../token/overlay/common/nonsense";
+
+import { JSON_DOCUMENT_TYPE } from "../documentTypes";
+
+const jsonLexer = JSONLexer.fromNothing(),
+      jsonParser = JSONParser.fromNothing();
+
+export default class JSONDocument extends Document {
+  static overlayTokenMap = {
+    "//error": ErrorOverlayToken,
+    "//nonsense": NonsenseOverlayToken
+  };
+
+  static fromContent(content) {
+    const type = JSON_DOCUMENT_TYPE,
+          lexer = jsonLexer,  ///
+          parser = jsonParser,  ///
+          jsonDocument = Document.fromContentTypeLexerAndParser(JSONDocument, content, type, lexer, parser);
+
+    return jsonDocument;
+  }
+}

package/src/document/markdown.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import { MarkdownLexer, MarkdownParser } from "highmark-markdown";
+
+import Document from "../document";
+import PathOverlayToken from "../token/overlay/markdown/path";
+import LinkOverlayToken from "../token/overlay/markdown/link";
+import ErrorOverlayToken from "../token/overlay/common/error";
+import TableOverlayToken from "../token/overlay/markdown/table";
+import ListingOverlayToken from "../token/overlay/markdown/listing";
+import HeadingOverlayToken from "../token/overlay/markdown/heading";
+import NonsenseOverlayToken from "../token/overlay/common/nonsense";
+import ReferenceOverlayToken from "../token/overlay/markdown/reference";
+
+import { MARKDOWN_DOCUMENT_TYPE } from "../documentTypes";
+
+const markdownLexer = MarkdownLexer.fromNothing(),
+      markdownParser = MarkdownParser.fromNothing();
+
+export default class MarkdownDocument extends Document {
+  static overlayTokenMap = {
+    "//error": ErrorOverlayToken,
+    "//nonsense": NonsenseOverlayToken,
+    "//reference": ReferenceOverlayToken,
+    "//tableDivider|tableCellDivider": TableOverlayToken,
+    "//footnoteLink|emailLink|hyperlink": LinkOverlayToken,
+    "//embedDirective|includeDirective/path": PathOverlayToken,
+    "//blockStart|blockEnd|blockLine|inlineListing": ListingOverlayToken,
+    "//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading": HeadingOverlayToken
+  };
+
+  static fromContent(content) {
+    const type = MARKDOWN_DOCUMENT_TYPE,
+          lexer = markdownLexer,  ///
+          parser = markdownParser,  ///
+          markdownDocument = Document.fromContentTypeLexerAndParser(MarkdownDocument, content, type, lexer, parser);
+
+    return markdownDocument;
+  }
+}

package/src/document/markdownStyle.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { MarkdownStyleLexer, MarkdownStyleParser } from "highmark-markdown";
+
+import Document from "../document";
+import NameOverlayToken from "../token/overlay/markdownStyle/name";
+import ValueOverlayToken from "../token/overlay/markdownStyle/value";
+import ErrorOverlayToken from "../token/overlay/common/error";
+import ContentOverlayToken from "../token/overlay/common/content";
+import NonsenseOverlayToken from "../token/overlay/common/nonsense";
+
+import { MARKDOWN_STYLE_DOCUMENT_TYPE } from "../documentTypes";
+
+const markdownStyleLexer = MarkdownStyleLexer.fromNothing(),
+      markdownStyleParser = MarkdownStyleParser.fromNothing();
+
+export default class MarkdownStyleDocument extends Document {
+  static overlayTokenMap = {
+    "//error": ErrorOverlayToken,
+    "//name": NameOverlayToken,
+    "//value": ValueOverlayToken,
+    "//nonsense": NonsenseOverlayToken,
+    "//content//*": ContentOverlayToken
+  };
+
+  static fromContent(content) {
+    const type = MARKDOWN_STYLE_DOCUMENT_TYPE,
+          lexer = markdownStyleLexer,  ///
+          parser = markdownStyleParser,  ///
+          markdownStyleDocument = Document.fromContentTypeLexerAndParser(MarkdownStyleDocument, content, type, lexer, parser);
+
+    return markdownStyleDocument;
+  }
+}

package/src/document/nominal.js

@@ -0,0 +1,56 @@
+"use strict";
+
+import { lexersUtilities, parsersUtilities } from "occam-nominal";
+
+import Document from "../document";
+import ErrorOverlayToken from "../token/overlay/common/error";
+import StuffOverlayToken from "../token/overlay/common/stuff";
+import NonsenseOverlayToken from "../token/overlay/common/nonsense";
+import LabelNameOverlayToken from "../token/overlay/common/labelName";
+import ReferenceNameOverlayToken from "../token/overlay/common/referenceName";
+import ProcedureReferenceNameOverlayToken from "../token/overlay/common/procedureReferenceName";
+
+import { NOMINAL_DOCUMENT_TYPE } from "../documentTypes";
+import { combinedCustomGrammarFromReleaseName } from "../utilities/customGrammars";
+
+const { nominalLexerFromNothing, nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromNothing, nominalParserFromCombinedCustomGrammar } = parsersUtilities;
+
+export default class NominalDocument extends Document {
+  static overlayTokenMap = {
+    "//error": ErrorOverlayToken,
+    "//stuff": StuffOverlayToken,
+    "//nonsense": NonsenseOverlayToken,
+    "//label/metavariable/@name": LabelNameOverlayToken,
+    "//procedureReference/@name": ProcedureReferenceNameOverlayToken,
+    "//reference/metavariable/@name": ReferenceNameOverlayToken
+  };
+
+  static fromContentAndReleaseName(content, releaseName) {
+    const type = NOMINAL_DOCUMENT_TYPE,
+          combinedCustomGrammar = combinedCustomGrammarFromReleaseName(releaseName),
+          nominalLexer = nominalLexerrFromCombinedCustomGrammar(combinedCustomGrammar),
+          nominalParser = nominalParserrFromCombinedCustomGrammar(combinedCustomGrammar),
+          lexer = nominalLexer, ///
+          parser = nominalParser, ///
+          nominalDocument = Document.fromContentTypeLexerAndParser(NominalDocument, content, type, lexer, parser, releaseName);
+
+    return nominalDocument;
+  }
+}
+
+function nominalLexerrFromCombinedCustomGrammar(combinedCustomGrammar) {
+  const nominalLexer = (combinedCustomGrammar !== null) ?
+                         nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar) :
+                           nominalLexerFromNothing();
+
+  return nominalLexer;
+}
+
+function nominalParserrFromCombinedCustomGrammar(combinedCustomGrammar) {
+  const nominalParser = (combinedCustomGrammar !== null) ?
+                          nominalParserFromCombinedCustomGrammar(combinedCustomGrammar) :
+                            nominalParserFromNothing();
+
+  return nominalParser;
+}

package/src/document/plainText.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { PlainTextLexer, PlainTextParser } from "occam-grammars";
+
+import Document from "../document";
+
+import { PLAIN_TEXT_DOCUMENT_TYPE } from "../documentTypes";
+
+const plainTextLexer = PlainTextLexer.fromNothing(),
+      plainTextParser = PlainTextParser.fromNothing();
+
+export default class PlainTextDocument extends Document {
+  static overlayTokenMap = {};
+
+  static fromContent(content) {
+    const type = PLAIN_TEXT_DOCUMENT_TYPE,
+          lexer = plainTextLexer,  ///
+          parser = plainTextParser,  ///
+          plainTextDocument = Document.fromContentTypeLexerAndParser(PlainTextDocument, content, type, lexer, parser);
+
+    return plainTextDocument;
+  }
+}

package/src/document.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import Overlay from "./overlay";
+
+import { tokensFromLines } from "./utilities/tokens";
+import { linesFromContent } from "./utilities/lines";
+
+export default class Document {
+  constructor(type, content, tokens, lines, node, overlay) {
+    this.type = type;
+    this.content = content;
+    this.tokens = tokens;
+    this.lines = lines;
+    this.node = node;
+    this.overlay = overlay;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getLines() {
+    return this.lines;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getOverlay() {
+    return this.overlay;
+  }
+
+  lineAsHTML(line) { return this.overlay.lineAsHTML(line); }
+
+  static fromContentTypeLexerAndParser(Class, content, type, lexer, parser) {
+    const { overlayTokenMap } = Class,
+          lines = linesFromContent(content, lexer),
+          tokens = tokensFromLines(lines),
+          node = parser.parse(tokens),
+          overlay = Overlay.fromNodeAndOverlayTokenMap(node, overlayTokenMap),
+          document = new Class(type, content, tokens, lines, node, overlay);
+
+    return document;
+  }
+}

package/src/documentTypes.js

@@ -0,0 +1,19 @@
+"use strict";
+
+export const BNF_DOCUMENT_TYPE = "bnf";
+export const JSON_DOCUMENT_TYPE = "json";
+export const FURTLE_DOCUMENT_TYPE = "furtle";
+export const NOMINAL_DOCUMENT_TYPE = "nominal";
+export const MARKDOWN_DOCUMENT_TYPE = "markdown";
+export const PLAIN_TEXT_DOCUMENT_TYPE = "plain-text";
+export const MARKDOWN_STYLE_DOCUMENT_TYPE = "markdown-style";
+
+export default {
+  BNF_DOCUMENT_TYPE,
+  JSON_DOCUMENT_TYPE,
+  FURTLE_DOCUMENT_TYPE,
+  NOMINAL_DOCUMENT_TYPE,
+  MARKDOWN_DOCUMENT_TYPE,
+  PLAIN_TEXT_DOCUMENT_TYPE,
+  MARKDOWN_STYLE_DOCUMENT_TYPE
+};