Let's Discuss Workflow: As a Chemical Engineer

[LynetteCullens]

TLDR

1. Add Variables using MathLinks
2. Add Equations via this plugin in callouts so that they can have Linked Variables.

General Workflow Template

• Variables and Linked Formulas are added to a file using mathLinks and mathLink-blocks (MathLinks Plugin) via:

1. Metadata Menu and Dataviewjs Table

• FileClass Definition

---
limit: 20
mapWithTag: false
icon: book-text
tagNames: 
filesPaths:
  - Glossary
bookmarksGroups: 
excludes: 
extends: 
savedViews: []
favoriteView: 
fieldsOrder:
  - AhkqXv
  - WYTa57
  - xlxkOB
  - VS6Uy8
  - n9uRB3
  - z6g6aA
  - PRLIYr
  - DykiIa
  - XnyDv1
  - lIGjtm
  - 83T7AI
  - 8PUkVv
  - LT3XIb
  - xEVKka
  - 6QSmrg
  - EEUXbq
  - aFXi9h
  - dpFopl
  - H27yPE
  - udXqgO
  - pQGPcE
  - gHaHOo
  - clmV6w
  - Ul4srw
  - lowZPd
  - w56uXb
  - qrhFOa
  - 2qcVc1
  - KqlXPM
  - LbPQmA
  - Cw4pu1
  - uDD3kr
  - Uevlxn
  - a67wIu
  - rxdY5b
  - BqVyq8
version: "2.111"
fields:
  - name: title
    type: Input
    options: {}
    path: ""
    id: AhkqXv
  - name: mathLink
    type: Input
    options: {}
    path: ""
    id: xlxkOB
  - name: mathLink-blocks
    type: Object
    options:
      displayTemplate: ""
    path: ""
    id: n9uRB3
  - name: AltNotation
    type: Input
    options: {}
    path: n9uRB3
    id: z6g6aA
  - name: Dimensions
    type: Input
    options: {}
    path: n9uRB3
    id: PRLIYr
  - name: LinkedDimensions
    type: Input
    options: {}
    path: n9uRB3
    id: DykiIa
  - name: StaticDimensions
    type: Input
    options: {}
    path: n9uRB3
    id: XnyDv1
  - name: LinkedStaticDimensions
    type: Input
    options: {}
    path: n9uRB3
    id: lIGjtm
  - name: MKS
    type: Input
    options: {}
    path: n9uRB3
    id: 83T7AI
  - name: CGS
    type: Input
    options: {}
    path: n9uRB3
    id: 8PUkVv
  - name: FPS
    type: Input
    options: {}
    path: n9uRB3
    id: LT3XIb
  - name: Formula
    type: Input
    options: {}
    path: n9uRB3
    id: xEVKka
  - name: Formula1
    type: Input
    options: {}
    path: n9uRB3
    id: EEUXbq
  - name: Formula2
    type: Input
    options: {}
    path: n9uRB3
    id: dpFopl
  - name: Formula3
    type: Input
    options: {}
    path: n9uRB3
    id: udXqgO
  - name: Formula4
    type: Input
    options: {}
    path: n9uRB3
    id: gHaHOo
  - name: Formula5
    type: Input
    options: {}
    path: n9uRB3
    id: Ul4srw
  - name: LinkedFormula
    type: Input
    options: {}
    path: n9uRB3
    id: 6QSmrg
  - name: LinkedFormula1
    type: Input
    options: {}
    path: n9uRB3
    id: aFXi9h
  - name: LinkedFormula2
    type: Input
    options: {}
    path: n9uRB3
    id: H27yPE
  - name: LinkedFormula3
    type: Input
    options: {}
    path: n9uRB3
    id: pQGPcE
  - name: LinkedFormula4
    type: Input
    options: {}
    path: n9uRB3
    id: clmV6w
  - name: LinkedFormula5
    type: Input
    options: {}
    path: n9uRB3
    id: lowZPd
  - name: aliases
    type: Input
    options: {}
    path: ""
    id: Cw4pu1
  - name: parent
    type: MultiFile
    options: {}
    path: ""
    id: uDD3kr
  - name: next
    type: MultiFile
    options: {}
    path: ""
    id: rxdY5b
    display: asList
  - name: Type
    type: Select
    options:
      sourceType: ValuesList
      valuesList:
        "1": Dimension
        "2": Variable
        "3": Math Operation
        "4": Vocabulary
        "5": Sub_Variable
        "6": Sub_Dimension
    path: ""
    id: WYTa57
  - name: ParentVariable
    type: MultiFile
    options: {}
    path: n9uRB3
    id: w56uXb
  - name: related
    type: MultiFile
    options: {}
    path: ""
    id: BqVyq8
    display: asList
  - name: dimensions
    type: MultiFile
    options: {}
    path: ""
    id: Uevlxn
  - name: staticdimensions
    type: MultiFile
    options: {}
    path: ""
    id: a67wIu
  - name: definition
    type: Input
    options: {}
    path: ""
    id: VS6Uy8
  - name: childdimensions
    type: Lookup
    options:
      autoUpdate: true
      dvQueryString: dv.pages('"Glossary"')
      targetFieldName: dimensions
      outputType: LinksList
      builtinSummarizingFunction: Count
      customListFunction: "\n"
      customSummarizingFunction: return pages.length
      summarizedFieldName: ""
    path: ""
    id: KqlXPM
  - name: childstaticdimensions
    type: Lookup
    options:
      autoUpdate: true
      dvQueryString: dv.pages('"Glossary"')
      targetFieldName: staticdimensions
      outputType: LinksList
      builtinSummarizingFunction: Count
      customListFunction: page.file.name
      customSummarizingFunction: return pages.length
      summarizedFieldName: ""
    path: ""
    id: LbPQmA
  - name: down
    type: Lookup
    options:
      autoUpdate: false
      dvQueryString: dv.pages('"Glossary"')
      targetFieldName: parent
      outputType: LinksList
      builtinSummarizingFunction: Count
      customListFunction: page.file.name
      customSummarizingFunction: return pages.length
      summarizedFieldName: ""
    path: ""
    id: qrhFOa
  - name: up
    type: Lookup
    options:
      autoUpdate: false
      dvQueryString: dv.pages('"Glossary"')
      targetFieldName: down
      outputType: LinksList
      builtinSummarizingFunction: Count
      customListFunction: page.file.name
      customSummarizingFunction: return pages.length
      summarizedFieldName: ""
    path: ""
    id: 2qcVc1
---

• Dataviewjs Table Query
  In General Yaml Editing

const {fieldModifier: f} = MetadataMenu.api;

const pageNum = dv.current().page;
const start = 10 * (pageNum - 1);
const end = 10 * pageNum;
const results = dv.pages('"Glossary"');
const totalPages = Math.ceil(results.length / 10);
const options = results.slice(0, totalPages).map((_, i) => `option(${i + 1})`).join(',');
const selector = `\`INPUT[inlineSelect(${options}):page]\``;
dv.span(`Page ${selector} out of *${totalPages}*`);
const rows = results.slice(start, end).map(p => [ 
		p.file.link,
		f(dv, p, "fileClass", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.AltNotation", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }), 
		f(dv, p, "mathLink-blocks.Dimensions", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedDimensions", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }), 
		f(dv, p, "mathLink-blocks.StaticDimensions", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedStaticDimensions", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.MKS", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.CGS", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.FPS", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedFormula", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedFormula1", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedFormula2", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedFormula3", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedFormula4", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "mathLink-blocks.LinkedFormula5", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "aliases", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "parent", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "same", {
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		f(dv, p, "type",{
                options: {
                    alwaysOn: true,
                    showAddField: true,
                    inFrontmatter: true
                }
            }),
		]);
const cols = ["File", "fileClass", "mathLink", "AltNotation", "Dimensions", "LinkedDimensions", "StaticDimensions", "LinkedStaticDimensions", "MKS", "CGS", "FPS", "LinkedFormula", "LinkedFormula1", "LinkedFormula2", "LinkedFormula3", "LinkedFormula4", "LinkedFormula5", "aliases", "parent", "same", "Type"];
dv.table(cols, rows)

MetaData Menu allows you to add properties and edit those properties without having to click on each individual file

3. MetaBind
   If you prefer to edit the frontmatter inline.
   Reading View
   
   Source Mode
   

• Equations are added via callouts using this plugin.

1. The displayed equation is entered using regular latex inline equation format.
2. The body of the callout is a reference to a mathLink-block that has that same equation in HTML format.
   Reading View
   
   Source Mode
   
   LinkedFormula
   

Table for Editing and Viewing Callouts

const { fieldModifier: f } = MetadataMenu.api;

(async () => {
    async function getContentAndLinkedContent(page) {
        const regex = />\s\[\!theorem\]\s(.+?)\n>\s%%\sdisplay:\s(.*?)\s%%\n>([\s\S]*?)(?=\n>|\n##)/gs;
        const file = app.vault.getAbstractFileByPath(page.file.path);
        const contents = await app.vault.read(file);
        const calloutsData = [];

        const matchMap = {
            "LinkedFormula5": "mathLink-blocks.LinkedFormula5",
            "LinkedFormula4": "mathLink-blocks.LinkedFormula4",
            "LinkedFormula3": "mathLink-blocks.LinkedFormula3",
            "LinkedFormula2": "mathLink-blocks.LinkedFormula2",
            "LinkedFormula1": "mathLink-blocks.LinkedFormula1",
            "LinkedFormula": "mathLink-blocks.LinkedFormula",
            "LinkedStaticDimensions": "mathLink-blocks.LinkedStaticDimensions",
            "LinkedDimensions": "mathLink-blocks.LinkedDimensions"
        };

        const matchMap2 = {
            "Formula5": "['mathLink-blocks'].Formula5",
            "LinkedFormula5": "['mathLink-blocks'].LinkedFormula5",
            "Formula4": "['mathLink-blocks'].Formula4",
            "LinkedFormula4": "['mathLink-blocks'].LinkedFormula4",
            "Formula3": "['mathLink-blocks'].Formula3",
            "LinkedFormula3": "['mathLink-blocks'].LinkedFormula3",
            "Formula2": "['mathLink-blocks'].Formula2",
            "LinkedFormula2": "['mathLink-blocks'].LinkedFormula2",
            "Formula1": "['mathLink-blocks'].Formula1",
            "LinkedFormula1": "['mathLink-blocks'].LinkedFormula1",
            "Formula": "['mathLink-blocks'].Formula",
            "LinkedFormula": "['mathLink-blocks'].LinkedFormula",
            "StaticDimensions": "['mathLink-blocks'].StaticDimensions",
            "LinkedStaticDimensions": "['mathLink-blocks'].LinkedStaticDimensions",
            "Dimensions": "['mathLink-blocks'].Dimensions",
            "LinkedDimensions": "['mathLink-blocks'].LinkedDimensions"
        };

        const matchMap3 = {
            "Formula5": "mathLink-blocks.Formula5",
            "Formula4": "mathLink-blocks.Formula4",
            "Formula3": "mathLink-blocks.Formula3",
            "Formula2": "mathLink-blocks.Formula2",
            "Formula1": "mathLink-blocks.Formula1",
            "Formula": "mathLink-blocks.Formula",
            "StaticDimensions": "mathLink-blocks.StaticDimensions",
            "Dimensions": "mathLink-blocks.Dimensions"
        };

        let match;
        while ((match = regex.exec(contents)) !== null) {
            let linkedContent = "";
            let editDisplay = "";

            for (const [key, value] of Object.entries(matchMap)) {
                if (match[3].includes(key)) {
                    linkedContent = await f(dv, page, value, {
                        options: {
                            alwaysOn: true,
                            showAddField: true,
                            inFrontmatter: true
                        }
                    });
                    break;
                }
            }

            for (const [key, value] of Object.entries(matchMap2)) {
                if (match[3].includes(key)) {
                    try {
                        const frontmatter = eval(`page.file.frontmatter${value}`);
                        if (frontmatter && frontmatter !== "[]") {
                            editDisplay = await f(dv, page, matchMap3[key], {
                                options: {
                                    alwaysOn: true,
                                    showAddField: true,
                                    inFrontmatter: true
                                }
                            });
                        }
                        break;
                    } catch (error) {
                        console.error(`Error fetching ${key} frontmatter:`, error);
                    }
                }
            }

            if (linkedContent !== null && linkedContent !== "" && linkedContent !== "[]") {
                calloutsData.push([page.file.link, match[1], match[2], match[3], linkedContent, editDisplay]);
            }
        }
        return calloutsData;
    }

    const pageSize = 10;
    const currentPage = dv.current()?.page || 1;
    const start = pageSize * (currentPage - 1);
    const end = pageSize * currentPage;

    // Fetch all data and flatten the array
    const allPagesData = (await Promise.all(
        dv.pages('"Glossary"').map(getContentAndLinkedContent)
    )).flat();

    // Apply filtering based on frontmatter
    const filteredData = allPagesData.filter(row => {
        const frontmatter = row[5]; // Adjusted index for editDisplay
        return frontmatter && frontmatter !== "[]";
    });

    const totalPages = Math.ceil(filteredData.length / pageSize);
    const options = Array.from({ length: totalPages }, (_, i) => `option(${i + 1})`).join(',');
    const selector = `\`INPUT[inlineSelect(${options}):page]\``;

    dv.span(`Page ${selector} out of *${totalPages}*`);

    // Display the filtered table
    const cols = ["File", "Callout Title", "Content", "Display", "Linked Contents", "Edit Display"];
    dv.table(cols, filteredData.slice(start, end));

    dv.current().page = currentPage;  // Ensure page number is updated
})();

this.container.classList.add("keep");

CSS Snippet Required to remove the extra stuff Generated in this table

.block-language-dataviewjs.keep > div:not(:has(> .dataview)) {
    display: none;
}

Plugins Required

• MathLinks
• Metadata Menu
• Meta Bind
• Editing Toolbar
• Dataview

CSS Snippets

To format fractions via HTML

span.frac {
  display: inline-block;
  font-size: 50%;
  text-align: center;
}
span.frac > sup {
  display: block;
  border-bottom: 1px solid;
  font: inherit;
}
span.frac > span {
  display: none;
}
span.frac > sub {
  display: block;
  font: inherit;
}

To align HTML Formulas

.center-align {
display: block;
text-align: center;
}

.right-align {
display: block;
text-align: right;
}

.left-align {
display: block;
text-align: left;
}

Editing Toolbar Commands to Add/Change Using Templater

Toggle Fraction (Addition)

<span style="font-size:200%;">[</span><span class="frac"><sup><% tp.file.cursor(1) %><%* app.workspace.activeLeaf.view.editor?.focus(); %></sup><span>/</span><sub><% tp.file.cursor(2) %><%* app.workspace.activeLeaf.view.editor?.focus(); %><sup><% tp.file.cursor(3) %><%* app.workspace.activeLeaf.view.editor?.focus(); %></sup></sub></span><span style="font-size:200%;">]</span>

Align Center (Change)

<span class="center-align"><% tp.file.selection ( ) %></span>

Align Left (Change)

<span class="left-align"><% tp.file.selection ( ) %></span>

Align Right (Change)

<span class="right-align"><% tp.file.selection ( ) %></span>

Resize Formulas (Addition)

<sup style="font-size:<% tp.file.cursor(1) %>%;"><% tp.file.selection ( ) %></span>