diff --git a/@webwriter/core/app-icon-transparent.svg b/@webwriter/core/app-icon-transparent.svg new file mode 100644 index 00000000..58266939 --- /dev/null +++ b/@webwriter/core/app-icon-transparent.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/@webwriter/core/localization/de.xlf b/@webwriter/core/localization/de.xlf index 6c382466..a64dfcce 100644 --- a/@webwriter/core/localization/de.xlf +++ b/@webwriter/core/localization/de.xlf @@ -682,10 +682,6 @@ Mark the selection as a superscript Markiere die Auswahl als hochgestellt - - subscript - Tiefgestellt - Mark the selection as a subscript Markiere die Auswahl als tiefgestellt @@ -774,6 +770,94 @@ Toggle Settings Einstellungen umschalten + + Mixed Content + Gemischter Inhalt + + + WebWriter does not support media of type + WebWriter unterstützt diesen Datentypen nicht + + + Subscript + Tiefgestellt + + + Insert a paragraph + Absatz einfügen + + + Blockquote + Blockzitat + + + Insert a blockquote + Blockzitat einfügen + + + Heading + Überschrift + + + Insert a heading (level 1) + Überschrift einfügen (Ebene 1) + + + Heading 2 + Überschrift 2 + + + Insert a heading (level 2) + Überschrift einfügen (Ebene 2) + + + Heading 3 + Überschrift 3 + + + Insert a heading (level 3) + Überschrift einfügen (Ebene 3) + + + List + Liste + + + Insert a list (unordered) + Liste einfügen (ungeordnet) + + + Ordered List + Geordnete Liste + + + Insert a list (ordered) + Liste einfügen (geordnet) + + + Task List + Aufgabenliste + + + Insert a list (tasks) + Liste einfügen (Aufgaben) + + + Table + Tabelle + + + Insert a table + Tabelle einfügen + + + Drawer + Schublade + + + Insert a drawer + Schublade einfügen + diff --git a/@webwriter/core/localization/generated/de.ts b/@webwriter/core/localization/generated/de.ts index bbb809f4..b63703d5 100644 --- a/@webwriter/core/localization/generated/de.ts +++ b/@webwriter/core/localization/generated/de.ts @@ -49,63 +49,62 @@ 's0184079b36201d24': `Dieses Widget hinzufügen`, 's0396202b716732ec': `Markiere die Auswahl als durchgestrichen`, 's03d2a538c7c99132': `Einstellungen umschalten`, +'s0978fb5ba3145996': `Liste einfügen (ungeordnet)`, 's09c3f1d21de14ae1': `Markiere die Auswahl als unterstrichen`, -'s0ae61a762cdd8ae8': `Es gibt ungesicherte Änderungen. Nochmal klicken, um die Änderungen zu verwerfen.`, 's0bdca49248ba4820': `Tastenkürzel`, 's0c883713b83616a8': `Speichere das aktive Dokument`, -'s0fbe1eb278c21168': `Dokument speichern unter... [STRG+S]`, 's10e80d4c01c3cc21': `Installiert`, 's11fdceabe7befeff': `Zugänglichkeit`, 's12aac40ecd87dc12': `Lokalen Anwendungs-Ordner öffnen`, 's13388f2a0641c5a9': `Von...`, 's1357c9b016a9a631': `CSS-Größe:`, 's1626a7e10a9f9dcc': `Legt die Schriftart der Auswahl fest`, +'s162f6f7ed3fc2584': `Schublade einfügen`, 's16f2f1c2c516d307': `Öffne ein Dokument`, 's1a2ba0c73ad1304c': `Schriftgröße verringern`, 's1cf730f96ac4f6b6': `Auf...`, 's1f0e5f8acab2f0d3': `Laden als...`, 's1f7698c061c208c9': `Öffnen`, -'s20c70732aecac427': `Nächster Tab`, -'s216346eda4b4203e': `Dokument speichern [STRG+S]`, -'s22dc82fb53ee2493': `Dokument öffnen [STRG+O]`, 's2540844a4bc4d9ba': `Namensnennung verlangen?`, 's255857544a9d5ec0': `Rücksetzen`, 's268ecd1cef45a9a8': `Bestätigen?`, 's2692bc028fed91f1': `⇪ Feststell`, +'s29eb103449472e3b': `Überschrift einfügen (Ebene 3)`, +'s29ee7434494a0dfe': `Überschrift einfügen (Ebene 2)`, +'s29f21c34494d614d': `Überschrift einfügen (Ebene 1)`, 's2a75c946ef4dcab7': `Sonstiges`, 's2b8f50c64be440f7': str`${0} auswählen...`, 's2ceb11be2290bb1b': `Abbrechen`, -'s2e787c95d8757702': `Formatiert den Absatz-Text als linksbündig`, +'s2f2044f2431a32d5': `Überschrift`, +'s337a1e9022a8d19f': `Tabelle`, 's33b62827f665c461': `Keine Pakete installiert`, 's33f85f24c0f5f008': `Speichern`, -'s34a149298b7c68ca': `Ungelistetes Paket hinzufügen`, +'s35aeaff1425bca9e': `WebWriter unterstützt diesen Datentypen nicht`, +'s35c3125c7750681e': `Blockzitat`, 's3643189d1abbb7f4': `Code`, +'s377e24af9628c37e': `Geordnete Liste`, 's37fa3b9cd51c2dfd': `Legt die Schriftgröße der Auswahl fest`, 's382a2aa3984474dd': `Erstellen`, 's38980f98cb07ceb8': `Speichere das aktive Dokument als Kopie`, -'s3a113cba87a8a856': `Neues Dokument`, 's3ae67088bbefba98': `Pakete`, 's3cf89cb47fdde7e9': `Link`, +'s3d249bb480032121': `Liste`, 's4023fcc0ecf63c51': `Öffnet oder schließt die Einstellungen-Schublade`, 's417b90913e05bc17': `Vorschau`, 's46d4abe6255cb9e1': `Kürzel neu zuweisen`, -'s4a77ad4a243a07e9': `Dokument drucken... [STRG+P]`, 's4caed5b7a7e5d89b': `Englisch`, 's4cb38675a21b2c98': ``, 's4f20edb48a6287c9': `Laden`, 's523eb9043213ff0d': `Kursiv`, -'s57ae2bdbf512b1ce': `Dokument öffnen`, +'s587ac858dd80f6fa': `Tiefgestellt`, 's599dcd2472c75c19': `Absatz`, -'s5c04918c08efdb71': `Absatz zentriert`, -'s5f343a43e7ea9f91': `Fehler`, +'s5b8cc9bb61ddce15': `Absatz einfügen`, 's600fd23c9ce971e8': `Drucke das aktive Dokument`, 's6196153c4b0c1ea0': `Installieren`, 's61e136c0658e27d5': `Protokoll`, -'s61e9429637594e7a': `Zeige Ordner`, 's63e71d20d1eaca93': `Deutsch`, 's640bc7710d0143ce': `Wiederhole die letzte rückgängig gemacht Änderung im aktiven Dokument`, 's64dc1fc7e3db45c9': `Erstelle ein neues Dokument`, -'s68768abc7f25154e': `Formatiert den Absatz-Text als zentriert`, 's6910ed6dbaba4807': `Ein Dokument laden`, 's739544d0c858c633': str`Oder ${0} hier ablegen`, 's74099020a06276df': `Dateien werden beobachtet`, @@ -123,12 +122,12 @@ 's8670e5ad3bf0dcf8': `Speichern unter`, 's8688d74dd3716d6e': `Tastenkürzel für Befehle`, 's889fce46bd2236e5': `Dokumente`, +'s88a62d29529948fb': `Tabelle einfügen`, 's8a7fa8a052138aef': `Warnung:`, 's8a9eb438abac7c6a': `Beschriftungen`, 's8b0432eecbd8b034': `Aktualisieren`, 's8cd9849cd37d7753': `Einen Ordner mit einem bestehenden Paket wählen zum installieren oder einen leeren Ordner, um ein neues Paket zu erstellen.`, 's8cfdd110c30d604d': `Keine Pakete installiert oder verfügbar`, -'s8da425b75207dba7': `Wähle den nächsten Dokumenten-Tab`, 's8f4be9f086eb530f': `Rückgängig`, 's8f533296a536965e': `Speichern unter...`, 's9017cdca3510148e': `Zeige eine Live-Vorschau, wenn die Maus über ein Widget in der Palette bewegt wird.`, @@ -140,11 +139,11 @@ 'sa00df4e39c72d3b4': str`${0} wird nicht unterstützt`, 'sa2ffa28d1155c0ff': `Erhöht die Schriftgröße der Auswahl`, 'sa3c9339de23c1752': `Format`, +'sa492a51a707930fa': `Blockzitat einfügen`, 'sa75b95980cd80e78': `Editor`, 'sab55faae8e165407': `Innenabstand <br> wie Außenabstand`, 'sad288b082f4d3521': `Das System scheint offline zu sein. Offline können verfügbare und veraltete Pakete nicht abgerufen werden.`, 'sae3629911a62147f': `JS-Größe:`, -'saecb138c1d98d05a': `Absatz rechtsbündig`, 'saf3da7c95cb17260': `Markiere die Auswahl als hochgestellt`, 'safc6f203342d09e2': `Vorschau für das aktive Dokument umschalten`, 'sb0a974028c99ca6d': `Adaptionen erlauben?`, @@ -156,40 +155,36 @@ 'sb9e9a7dd45966756': `Markiere die Auswahl als fett`, 'sba509fd8ed61d1d5': `Ungespeicherte Datei`, 'sbc5bb5bb74d141b9': `Deinstallieren`, -'sc00a88b90cd60661': `Verwerfen`, +'sbc5f2d81604bb4b4': `Überschrift 3`, +'sbc5f2e81604bb667': `Überschrift 2`, 'sc221faca1ecb4aee': `Anonym`, 'sc3ac225273c8316b': `Allgemeines`, 'sc5cb39478b9b7625': `Markiere die Auswahl als tiefgestellt`, 'sc7691fecb3373a42': `Keine lokalen Pakete`, +'scd0ddab5a7a0f930': `Schublade`, 'scf735dfae10f3870': `Bildung`, 'sd158a5fc0f062f18': `Verfügbar`, -'sd44f17e53e86b071': `Absatz im Blocksatz`, -'sd641695ca0a3037d': `Dokument schließen [STRG+W]`, -'sd6e97f557fbc7d0f': `Formatiert den Absatz-Text als rechtsbündig`, 'sd846987afc2e2cde': `Zeige einen Platzhalter-Text, wenn ein Dokument leer ist`, -'sd9a5cf6507662514': `Formatiert den Absatz-Text als im Blocksatz`, 'sda174a4c93e84ce6': `Fehler beim Importieren von`, +'sdb711380a28fec75': `Liste einfügen (geordnet)`, 'sdcd1efc06af80825': `Alle Rechte vorbehalten`, 'sddc49047f66a64ab': `Keine Beschreibung verfügbar`, -'sde1831f28fdab23b': `Schließe das aktive Dokument`, 'sded940efcadd8f10': `Das Dokument speichern`, 'sdf946172dfa0328f': `Hochgestellt`, +'se036b53f145441cd': `Gemischter Inhalt`, 'se25e4f2cb77b8be8': `Sprache für das WebWriter-Interface und neue Dokumente`, 'se3b4c857f91f80d7': `Tastenkürzel`, 'se400c16740eb77dc': `Zeige Widget-Vorschau`, 'se432a7c0c144d458': `Keine Pakete verfügbar`, 'se58f06c2b0583ff7': `Koordinaten wählen`, 'se59ef70a4d2cfbac': `Lade WebWriter...`, -'se8a370b9a39c9c5e': `Dokument erstellen [STRG+N]`, 'se9b1fec72ffd8f48': `Lokal`, 'seaf97719986faf4f': `Abstand`, 'sec4cb64c35332774': `Zeige einen Platzhalter-Text`, 'sed8ec5e3c64fa25d': `Gesamt`, 'see2fcaedf9743ec6': `Ort`, -'see30e82e495e3e22': `Lokale Pakete sind für Entwickler gedacht.`, 'seec6798afe90ffc8': `Drucken`, 'sefcf950b3cc4fc3b': `Sprache`, -'sf1e2ccb43f3cca39': `Absatz linksbündig`, 'sf1e79171c4856543': `Bist du sicher? Diese Aktion kann nicht rückgängig gemacht werden, alle Einstellungen werden zurückgesetzt.`, 'sf1ed4eed4de3012e': `Fehler anzeigen`, 'sf65df67a03bebe4b': `Erforderlich für dieses Widget`, @@ -201,6 +196,50 @@ 'spaceKey': `Leertaste`, 'tabKey': `⭾ Tab`, 'upKey': `↑ Hoch`, -'s587ac858dd80f6fa': `Subscript`, +'sf9f2c719a04066ec': `App`, +'sa311a24c1471a974': `Document`, +'sb1494c08c8c720d1': `Set text color`, +'se1f5bb0386c88f96': `Sets the color of the selected text`, +'sa65d4ad99f1d8c06': `Set text background`, +'s34f724979a124c50': `Sets the background color of the selected text`, +'s163770926259036e': `Set line height`, +'s116a50d707724ebf': `Set the line height of the selected block`, +'s1c060a5ea3eff2d0': `Set block border`, +'se94aa491754e67ac': `Set the border of the selected block`, +'s7c70d0bf2a12e88c': `Set block margin`, +'s24baf36b963988d1': `Set the margins of the selected block`, +'s1570e1200a882f33': `Set block padding`, +'sbf89a6f724bef29f': `Set the padding of the selected block`, +'s425e266433a1ebca': `Set block background`, +'sc60e0271fdc285f2': `Set the background of the selected block`, +'s3b3cfb9df7a16976': `Align block text`, +'s5a0742dba0defaec': `Set the text alignment of the selected block`, +'sbc5f2c81604bb301': `Heading 4`, +'s2a031834495bcdb4': `Insert a heading (level 4)`, +'sbc5f2b81604bb14e': `Heading 5`, +'s29ff743449588131': `Insert a heading (level 5)`, +'sbc5f2a81604baf9b': `Heading 6`, +'s29fbfc3449557f72': `Insert a heading (level 6)`, +'sa645d315510dc09e': `Choose path from disk`, +'seabae79729c4b2ad': `Toggle email`, +'s34dcda3b0f9d5a98': `Toggle url`, +'sb8f855b49234b81b': `Apply`, +'sb66beca1e766dcb3': `Apply and import`, +'s3914cb410fca44d4': `Import`, +'sed17285cd25d6389': `Directory where package.json is located`, +'sc74e3567875ce255': `Both the tag of your widget and the name of your NPM package`, +'s342b0cabfa672822': `Help the user find your widget`, +'sfdeef3dccf409f81': `This keyword is required for widgets`, +'h64cd12550420f6f1': html`Generate a LICENSE file`, +'s0dc452999c129e15': `Enable live reload`, +'s2591806d7b222591': `Reset changes`, +'s445b8acb9206db6e': `Discard and cancel`, +'sdb311229f4b5eb3b': `Import local package`, +'s65f6740a45cea0aa': `Create local package`, +'s3a6538ae341633f6': `Edit local package`, +'s9bf0b9da3f509795': `Widget Package`, +'s2492f5fb1b05b45e': `Text`, +'sf6673729c03ae999': `Reset WebWriter`, +'s7b5d09422b533af9': `View App Folder`, }; \ No newline at end of file diff --git a/@webwriter/core/model/environment/index.ts b/@webwriter/core/model/environment/index.ts index fb9eafdb..b17acc6f 100644 --- a/@webwriter/core/model/environment/index.ts +++ b/@webwriter/core/model/environment/index.ts @@ -1,3 +1,4 @@ +import { WindowOptions } from "@tauri-apps/api/window"; import { Package } from ".." export * from "./tauri" @@ -128,5 +129,6 @@ export type Environment = { search: (text: string, params?: {size?: number, from?: number, quality?: number, popularity?: number, maintenance?: number}, searchEndpoint?: string) => Promise, pm: (command: string, commandArgs?: string[], json?: boolean, cwd?: string) => Promise, watch: (paths: string | string[], cb?: (event: WatchEvent) => void, options?: {recursive?: boolean, delayMs?: number}) => Promise<() => void> - getSystemFonts: () => Promise + getSystemFonts: () => Promise, + createWindow: (url: string, options?: WindowOptions) => Promise } \ No newline at end of file diff --git a/@webwriter/core/model/environment/tauri.ts b/@webwriter/core/model/environment/tauri.ts index b569a123..4fe64724 100644 --- a/@webwriter/core/model/environment/tauri.ts +++ b/@webwriter/core/model/environment/tauri.ts @@ -1,12 +1,13 @@ -import {readTextFile, readBinaryFile, writeTextFile, writeBinaryFile, removeFile, readDir, createDir, removeDir, exists, renameFile} from '@tauri-apps/api/fs' -import {join, normalize, basename, dirname, extname, resolve, isAbsolute, appDataDir as appDir} from '@tauri-apps/api/path' +import {readTextFile, readBinaryFile, writeTextFile, writeBinaryFile, removeFile, readDir, createDir, removeDir, exists, renameFile} from "@tauri-apps/api/fs" +import {join, normalize, basename, dirname, extname, resolve, isAbsolute, appDataDir as appDir} from "@tauri-apps/api/path" import {Command, open} from "@tauri-apps/api/shell" import {arch, platform} from "@tauri-apps/api/os" import {open as promptRead, save as promptWrite} from "@tauri-apps/api/dialog" import {fetch, Body, ResponseType} from "@tauri-apps/api/http" import {Buffer} from "buffer"; window.Buffer = Buffer import {metadata} from "tauri-plugin-fs-extra-api" -import { invoke } from '@tauri-apps/api/tauri' +import { invoke } from "@tauri-apps/api/tauri" +import { WebviewWindow, WindowOptions } from "@tauri-apps/api/window" import { DialogAPI, FileSystemAPI, HTTPAPI, OSAPI, PathAPI, Response, ShellAPI, Stats } from "." @@ -173,9 +174,9 @@ export async function pm(command: string, commandArgs: string[] = [], json=true, const err = output.stderr.split("\n").map((e: any) => JSON.parse(e)) const errors = err.filter((e: any) => e.type === "error") const warnings = err.filter((e: any) => e.type === "warning") - warnings.forEach((w: any) => console.warn(w)) + warnings.forEach((w: any) => console.warn(w.data)) if(err?.some((e: any) => e?.type === "error")) { - throw AggregateError(errors) + throw err } } else { @@ -187,6 +188,16 @@ export async function pm(command: string, commandArgs: string[] = [], json=true, } } +/** Get the names of all fonts installed on the user's system. */ export function getSystemFonts() { return invoke("get_system_fonts") +} + +/** Create a new window. */ +export async function createWindow(url: string, options?: WindowOptions): Promise { + const webview = new WebviewWindow(url, {url: "index.html", ...options}) + return new Promise((resolve, reject) => { + webview.once("tauri://created", () => resolve(url)) + webview.once("tauri://error", e => reject(e)) + }) } \ No newline at end of file diff --git a/@webwriter/core/model/schemas/contentexpression/index.ts b/@webwriter/core/model/schemas/contentexpression/index.ts new file mode 100644 index 00000000..0d490e05 --- /dev/null +++ b/@webwriter/core/model/schemas/contentexpression/index.ts @@ -0,0 +1,84 @@ +import {z} from "zod" +import {Schema} from "prosemirror-model" +//@ts-ignore +import { parse } from "./parse" + +export type Expression = SimpleExpression | Sequence | Alternation | NodeExpression + +export interface BaseExpression { + type: string + min: number + max: number + raw: string +} + +export interface SimpleExpression extends BaseExpression { + type: "SimpleExpression" + content: string +} + +export interface NodeExpression extends BaseExpression { + type: "NodeExpression" + node: string + content?: Expression[] +} + +export interface Sequence extends BaseExpression { + type: "Sequence" + content: Expression[] +} + +export interface Alternation extends BaseExpression { + type: "Alternation" + content: Expression[] +} + + +export type ContentExpression = z.infer +export const ContentExpression = Object.assign(z.string().transform(arg => parse(arg)), { + serialize(value: Expression) { + return value.raw + }, + resolve(schema: Schema, expression: ParentedExpression, parent?: ParentedExpression): ParentedExpression { + const {content} = expression + const representants = {} as Record + Object.entries(schema.nodes).reverse().forEach(([k, v]) => { + representants[k] = k + if(v.spec.group) { + representants[v.spec.group] = k + } + }) + if(typeof content === "string" && (schema.nodes[representants[content]])) { + const node = schema.nodes[representants[content]] + const result = { + ...expression, + type: "NodeExpression", + node: node.name, + parent + } + const nodeContent = node.spec.content + ? ContentExpression.resolve(schema, ContentExpression.parse(node.spec.content), result as any) + : undefined + return Object.assign(result, {content: nodeContent? [nodeContent]: undefined}) as any + } + else if(Array.isArray(content)) { + const result = { + ...expression as Exclude, + parent + } + return Object.assign(result, {content: content.map(c => ContentExpression.resolve(schema, c, result))}) + } + else { + return expression + } + }, + values(expression: ParentedExpression): ParentedExpression[] { + const {content} = expression + const values = !content || typeof content === "string" + ? [] + : content.flatMap(c => ContentExpression.values(c)) + return [expression, ...values] + } +}) + +export type ParentedExpression = Expression & {parent?: ParentedExpression} \ No newline at end of file diff --git a/@webwriter/core/model/schemas/contentexpression/parse.js b/@webwriter/core/model/schemas/contentexpression/parse.js new file mode 100644 index 00000000..425723ed --- /dev/null +++ b/@webwriter/core/model/schemas/contentexpression/parse.js @@ -0,0 +1,1290 @@ +"use strict"; + +function peg$subclass(child, parent) { + function C() { this.constructor = child; } + C.prototype = parent.prototype; + child.prototype = new C(); +} + +function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + // istanbul ignore next Check is a necessary evil to support older environments + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; +} + +peg$subclass(peg$SyntaxError, Error); + +function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { return str; } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); +} + +peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = (this.location.source && (typeof this.location.source.offset === "function")) + ? this.location.source.offset(s) + : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, ' '); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = (last - s.column) || 1; + str += "\n --> " + loc + "\n" + + filler + " |\n" + + offset_s.line + " | " + line + "\n" + + filler + " | " + peg$padEnd("", s.column - 1, ' ') + + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; +}; + +peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return "\"" + literalEscape(expectation.text) + "\""; + }, + + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) + ? classEscape(part[0]) + "-" + classEscape(part[1]) + : classEscape(part); + }); + + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + + any: function() { + return "any character"; + }, + + end: function() { + return "end of input"; + }, + + other: function(expectation) { + return expectation.description; + } + }; + + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + + function literalEscape(s) { + return s + .replace(/\\/g, "\\\\") + .replace(/"/g, "\\\"") + .replace(/\0/g, "\\0") + .replace(/\t/g, "\\t") + .replace(/\n/g, "\\n") + .replace(/\r/g, "\\r") + .replace(/[\x00-\x0F]/g, function(ch) { return "\\x0" + hex(ch); }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x" + hex(ch); }); + } + + function classEscape(s) { + return s + .replace(/\\/g, "\\\\") + .replace(/\]/g, "\\]") + .replace(/\^/g, "\\^") + .replace(/-/g, "\\-") + .replace(/\0/g, "\\0") + .replace(/\t/g, "\\t") + .replace(/\n/g, "\\n") + .replace(/\r/g, "\\r") + .replace(/[\x00-\x0F]/g, function(ch) { return "\\x0" + hex(ch); }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x" + hex(ch); }); + } + + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + + function describeExpected(expected) { + var descriptions = expected.map(describeExpectation); + var i, j; + + descriptions.sort(); + + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + + switch (descriptions.length) { + case 1: + return descriptions[0]; + + case 2: + return descriptions[0] + " or " + descriptions[1]; + + default: + return descriptions.slice(0, -1).join(", ") + + ", or " + + descriptions[descriptions.length - 1]; + } + } + + function describeFound(found) { + return found ? "\"" + literalEscape(found) + "\"" : "end of input"; + } + + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; +}; + +function peg$parse(input, options) { + options = options !== undefined ? options : {}; + + var peg$FAILED = {}; + var peg$source = options.grammarSource; + + var peg$startRuleFunctions = { Expression: peg$parseExpression }; + var peg$startRuleFunction = peg$parseExpression; + + var peg$c0 = " "; + var peg$c1 = "("; + var peg$c2 = ")"; + var peg$c3 = "|"; + var peg$c4 = "*"; + var peg$c5 = "+"; + var peg$c6 = "?"; + var peg$c7 = "{"; + var peg$c8 = "}"; + var peg$c9 = ","; + + var peg$r0 = /^[_a-zA-Z]/; + var peg$r1 = /^[_a-zA-Z0-9]/; + var peg$r2 = /^[0-9]/; + var peg$r3 = /^[ \t\n\r]/; + + var peg$e0 = peg$literalExpectation(" ", false); + var peg$e1 = peg$literalExpectation("(", false); + var peg$e2 = peg$literalExpectation(")", false); + var peg$e3 = peg$literalExpectation("|", false); + var peg$e4 = peg$classExpectation(["_", ["a", "z"], ["A", "Z"]], false, false); + var peg$e5 = peg$classExpectation(["_", ["a", "z"], ["A", "Z"], ["0", "9"]], false, false); + var peg$e6 = peg$literalExpectation("*", false); + var peg$e7 = peg$literalExpectation("+", false); + var peg$e8 = peg$literalExpectation("?", false); + var peg$e9 = peg$literalExpectation("{", false); + var peg$e10 = peg$classExpectation([["0", "9"]], false, false); + var peg$e11 = peg$literalExpectation("}", false); + var peg$e12 = peg$literalExpectation(",", false); + var peg$e13 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false); + + var peg$f0 = function(expression, quantifier) { + return {...expression, ...(quantifier ?? {min: expression.min ?? 1, max: expression.max ?? 1}), raw: text()} +}; + var peg$f1 = function(head, tail) { + return {type: "Sequence", content: [head, ...tail], min: 1, max: 1, raw: text()} +}; + var peg$f2 = function(head, tail) { + return {type: "Alternation", content: [head, ...tail], min: 1, max: 1, raw: text()} +}; + var peg$f3 = function(content, quantifier) { + return {type: "SimpleExpression", content, ...(quantifier ?? {min: 1, max: 1}), raw: text()} +}; + var peg$f4 = function() { + return {min: 0, max: Number.POSITIVE_INFINITY} +}; + var peg$f5 = function() { + return {min: 1, max: Number.POSITIVE_INFINITY} +}; + var peg$f6 = function() { + return {min: 0, max: 1} +}; + var peg$f7 = function(valStr) { + let min, max; min = max = parseInt(valStr.join("")) + return {min, max} +}; + var peg$f8 = function(minStr, maxStr) { + let min = parseInt(minStr.join("")) + let max = parseInt(maxStr.join("")) + min > max? error("min must be less than or equal to max"): null + return {min, max} +}; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + + var peg$result; + + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error("Can't start parsing from rule \"" + options.startRule + "\"."); + } + + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + + function offset() { + return peg$savedPos; + } + + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + + function expected(description, location) { + location = location !== undefined + ? location + : peg$computeLocation(peg$savedPos, peg$currPos); + + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location + ); + } + + function error(message, location) { + location = location !== undefined + ? location + : peg$computeLocation(peg$savedPos, peg$currPos); + + throw peg$buildSimpleError(message, location); + } + + function peg$literalExpectation(text, ignoreCase) { + return { type: "literal", text: text, ignoreCase: ignoreCase }; + } + + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase }; + } + + function peg$anyExpectation() { + return { type: "any" }; + } + + function peg$endExpectation() { + return { type: "end" }; + } + + function peg$otherExpectation(description) { + return { type: "other", description: description }; + } + + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + + p++; + } + + peg$posDetailsCache[pos] = details; + + return details; + } + } + + function peg$computeLocation(startPos, endPos, offset) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + if (offset && peg$source && (typeof peg$source.offset === "function")) { + res.start = peg$source.offset(res.start); + res.end = peg$source.offset(res.end); + } + return res; + } + + function peg$fail(expected) { + if (peg$currPos < peg$maxFailPos) { return; } + + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + + peg$maxFailExpected.push(expected); + } + + function peg$buildSimpleError(message, location) { + return new peg$SyntaxError(message, null, null, location); + } + + function peg$buildStructuredError(expected, found, location) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected, found), + expected, + found, + location + ); + } + + function peg$parseExpression() { + var s0; + + s0 = peg$parseGroup(); + if (s0 === peg$FAILED) { + s0 = peg$parseSequence(); + if (s0 === peg$FAILED) { + s0 = peg$parseAlternation(); + if (s0 === peg$FAILED) { + s0 = peg$parseSimpleExpression(); + } + } + } + + return s0; + } + + function peg$parseGroup() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s3 = peg$c0; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.charCodeAt(peg$currPos) === 32) { + s3 = peg$c0; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$silentFails--; + peg$currPos = s1; + s1 = undefined; + if (input.charCodeAt(peg$currPos) === 40) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e1); } + } + if (s2 !== peg$FAILED) { + s3 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s4 !== peg$FAILED) { + s3.push(s4); + if (input.charCodeAt(peg$currPos) === 32) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + s4 = peg$parseExpression(); + if (s4 !== peg$FAILED) { + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + if (input.charCodeAt(peg$currPos) === 41) { + s6 = peg$c2; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e2); } + } + if (s6 !== peg$FAILED) { + s7 = peg$parseQuantifier(); + if (s7 === peg$FAILED) { + s7 = null; + } + s8 = peg$currPos; + peg$silentFails++; + s9 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s10 = peg$c0; + peg$currPos++; + } else { + s10 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s10 !== peg$FAILED) { + s9.push(s10); + if (input.charCodeAt(peg$currPos) === 32) { + s10 = peg$c0; + peg$currPos++; + } else { + s10 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$silentFails--; + peg$currPos = s8; + s8 = undefined; + peg$savedPos = s0; + s0 = peg$f0(s4, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSequence() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s2 = peg$c0; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 32) { + s2 = peg$c0; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + s2 = peg$parseGroup(); + if (s2 === peg$FAILED) { + s2 = peg$parseAlternation(); + if (s2 === peg$FAILED) { + s2 = peg$parseSimpleExpression(); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parseGroup(); + if (s6 === peg$FAILED) { + s6 = peg$parseAlternation(); + if (s6 === peg$FAILED) { + s6 = peg$parseSimpleExpression(); + } + } + if (s6 !== peg$FAILED) { + s4 = s6; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parseGroup(); + if (s6 === peg$FAILED) { + s6 = peg$parseAlternation(); + if (s6 === peg$FAILED) { + s6 = peg$parseSimpleExpression(); + } + } + if (s6 !== peg$FAILED) { + s4 = s6; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s5 = peg$c0; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (input.charCodeAt(peg$currPos) === 32) { + s5 = peg$c0; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$savedPos = s0; + s0 = peg$f1(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAlternation() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s3 = peg$c0; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.charCodeAt(peg$currPos) === 32) { + s3 = peg$c0; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$silentFails--; + peg$currPos = s1; + s1 = undefined; + s2 = peg$parseGroup(); + if (s2 === peg$FAILED) { + s2 = peg$parseSimpleExpression(); + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + if (input.charCodeAt(peg$currPos) === 124) { + s6 = peg$c3; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e3); } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s8 = peg$c0; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s8 !== peg$FAILED) { + s7.push(s8); + if (input.charCodeAt(peg$currPos) === 32) { + s8 = peg$c0; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + s8 = peg$parseGroup(); + if (s8 === peg$FAILED) { + s8 = peg$parseSimpleExpression(); + } + if (s8 !== peg$FAILED) { + s4 = s8; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + if (input.charCodeAt(peg$currPos) === 124) { + s6 = peg$c3; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e3); } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s8 = peg$c0; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s8 !== peg$FAILED) { + s7.push(s8); + if (input.charCodeAt(peg$currPos) === 32) { + s8 = peg$c0; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + s8 = peg$parseGroup(); + if (s8 === peg$FAILED) { + s8 = peg$parseSimpleExpression(); + } + if (s8 !== peg$FAILED) { + s4 = s8; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + peg$silentFails++; + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$silentFails--; + peg$currPos = s4; + s4 = undefined; + peg$savedPos = s0; + s0 = peg$f2(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSimpleExpression() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s3 = peg$c0; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.charCodeAt(peg$currPos) === 32) { + s3 = peg$c0; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$silentFails--; + peg$currPos = s1; + s1 = undefined; + s2 = peg$parseToken(); + if (s2 !== peg$FAILED) { + s3 = peg$parseQuantifier(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$currPos; + peg$silentFails++; + s5 = []; + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (input.charCodeAt(peg$currPos) === 32) { + s6 = peg$c0; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e0); } + } + } + peg$silentFails--; + peg$currPos = s4; + s4 = undefined; + peg$savedPos = s0; + s0 = peg$f3(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseToken() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$currPos; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e4); } + } + if (s2 !== peg$FAILED) { + s3 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e5); } + } + while (s4 !== peg$FAILED) { + s3.push(s4); + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e5); } + } + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + + return s0; + } + + function peg$parseStar() { + var s0, s1; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 42) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e6); } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(); + } + s0 = s1; + + return s0; + } + + function peg$parsePlus() { + var s0, s1; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e7); } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(); + } + s0 = s1; + + return s0; + } + + function peg$parseQuestion() { + var s0, s1; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 63) { + s1 = peg$c6; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e8); } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f6(); + } + s0 = s1; + + return s0; + } + + function peg$parseSingleQuantifier() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e9); } + } + if (s1 !== peg$FAILED) { + s2 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e10); } + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$r2.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e10); } + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c8; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e11); } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDoubleQuantifier() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e9); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + s3 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e10); } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + if (peg$r2.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e10); } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c9; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e12); } + } + if (s4 !== peg$FAILED) { + s5 = peg$parse_(); + s6 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e10); } + } + if (s7 !== peg$FAILED) { + while (s7 !== peg$FAILED) { + s6.push(s7); + if (peg$r2.test(input.charAt(peg$currPos))) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e10); } + } + } + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parse_(); + if (input.charCodeAt(peg$currPos) === 125) { + s8 = peg$c8; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e11); } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f8(s3, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseQuantifier() { + var s0; + + s0 = peg$parseStar(); + if (s0 === peg$FAILED) { + s0 = peg$parsePlus(); + if (s0 === peg$FAILED) { + s0 = peg$parseQuestion(); + if (s0 === peg$FAILED) { + s0 = peg$parseSingleQuantifier(); + if (s0 === peg$FAILED) { + s0 = peg$parseDoubleQuantifier(); + } + } + } + } + + return s0; + } + + function peg$parse_() { + var s0, s1; + + s0 = []; + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e13); } + } + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$e13); } + } + } + + return s0; + } + + peg$result = peg$startRuleFunction(); + + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length + ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) + : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } +} + +export const SyntaxError = peg$SyntaxError +export const parse = peg$parse diff --git a/@webwriter/core/model/schemas/contentexpression/parse.pegjs b/@webwriter/core/model/schemas/contentexpression/parse.pegjs new file mode 100644 index 00000000..3cb017bb --- /dev/null +++ b/@webwriter/core/model/schemas/contentexpression/parse.pegjs @@ -0,0 +1,50 @@ +Expression + = Group/Sequence/Alternation/SimpleExpression + +Group = &" "* "(" " "* expression:Expression " "* ")" quantifier:Quantifier? &" "* { + return {...expression, ...(quantifier ?? {min: expression.min ?? 1, max: expression.max ?? 1}), raw: text()} +} + +Sequence = " "* head:(Group/Alternation/SimpleExpression) tail:(" "+ @value:(Group/Alternation/SimpleExpression))+ " "* { + return {type: "Sequence", content: [head, ...tail], min: 1, max: 1, raw: text()} +} + +Alternation = &" "* head:(Group/SimpleExpression) tail:(" "* "|" " "* @value:(Group/SimpleExpression))+ &" "* { + return {type: "Alternation", content: [head, ...tail], min: 1, max: 1, raw: text()} +} + +SimpleExpression = &" "* content:Token quantifier:Quantifier? &" "* { + return {type: "SimpleExpression", content, ...(quantifier ?? {min: 1, max: 1}), raw: text()} +} + +Token + = $([_a-zA-Z][_a-zA-Z0-9]*) + +Star = "*" { + return {min: 0, max: Number.POSITIVE_INFINITY} +} + +Plus = "+" { + return {min: 1, max: Number.POSITIVE_INFINITY} +} + +Question = "?" { + return {min: 0, max: 1} +} + +SingleQuantifier = "{"valStr:([0-9]+)"}" { + let min, max; min = max = parseInt(valStr.join("")) + return {min, max} +} + +DoubleQuantifier = '{' _ minStr:([0-9]+)',' _ maxStr:([0-9]+) _ '}' { + let min = parseInt(minStr.join("")) + let max = parseInt(maxStr.join("")) + min > max? error("min must be less than or equal to max"): null + return {min, max} +} + +Quantifier = Star / Plus / Question / SingleQuantifier / DoubleQuantifier + +_ + = [ \t\n\r]* \ No newline at end of file diff --git a/@webwriter/core/model/schemas/index.ts b/@webwriter/core/model/schemas/index.ts index 56596e0b..1e5efcbe 100644 --- a/@webwriter/core/model/schemas/index.ts +++ b/@webwriter/core/model/schemas/index.ts @@ -1,2 +1,40 @@ +import { z, ZodError, ZodSchema, ZodType } from "zod"; +import { fromZodError } from "zod-validation-error"; +import { Package } from "./packageschema"; + +export * from "./contentexpression" +export * from "./resourceschema" export * from "./packageschema" -export * from "./resourceschema" \ No newline at end of file + +export type Constructor = new (...args: any[]) => T; + +export function DataType(schema: T) { + abstract class BaseDataType { + + constructor(data: unknown, params?: Partial) { + try { + Object.assign(this, schema.parse(data, params)) + } + catch(err) { + throw new Error(fromZodError(err as ZodError, {prefix: `${this.constructor.name}`}).message) + + } + } + + abstract serialize(format?: string): any + + toString() { + return this.serialize() + } + + toJSON() { + return this.serialize() + } + + static get schema(): T { + return schema.transform(value => new (this as any)(value)) as any + } + } + + return Object.assign(BaseDataType, schema) as unknown as (typeof BaseDataType) & Constructor> & T +} \ No newline at end of file diff --git a/@webwriter/core/model/schemas/packageschema.ts b/@webwriter/core/model/schemas/packageschema.ts deleted file mode 100644 index b4767130..00000000 --- a/@webwriter/core/model/schemas/packageschema.ts +++ /dev/null @@ -1,246 +0,0 @@ -// @ts-strict -import {z} from "zod" -import SPDX_LICENSE_MAP from "spdx-license-list" -import {valid as semverValid, validRange as semverValidRange} from "semver" -import {ContentMatch, Schema} from "prosemirror-model" -import { baseSchema, createSchemaSpec } from "./resourceschema" - -const SPDX_LICENSES = Object.keys(SPDX_LICENSE_MAP) -const NODE_BUILTINS = [ - 'assert', - 'buffer', - 'child_process', - 'cluster', - 'console', - 'constants', - 'crypto', - 'dgram', - 'dns', - 'domain', - 'events', - 'fs', - 'http', - 'https', - 'module', - 'net', - 'os', - 'path', - 'punycode', - 'querystring', - 'readline', - 'repl', - 'stream', - 'string_decoder', - 'sys', - 'timers', - 'tls', - 'tty', - 'url', - 'util', - 'vm', - 'zlib', - 'freelist', - 'v8', - 'process', - 'inspector', - 'async_hooks', - 'http2', - 'perf_hooks', - 'trace_events', - 'worker_threads', - 'node:test', - 'wasi', - 'diagnostics_channel' -] -const NODE_PLATFORMS = [ - 'aix', - 'darwin', - 'freebsd', - 'linux', - 'openbsd', - 'sunos', - 'win32' -] -const NODE_ARCHS = [ - 'arm', - 'arm64', - 'ia32', - 'mips', - 'mipsel', - 'ppc', - 'ppc64', - 's390', - 's390x', - 'x64' -] - -const nonUrlSafePattern = /(?!\{|\}|\||\\|\^|~|\[|\]|\`)/ -const nonNpmBlacklistPattern = /^(?!node_modules|favicon\.ico).+$/ -const nonNodeBuiltinPattern = new RegExp(`^(?!${NODE_BUILTINS.join("|")}).*$`) -const spdxLicensePattern = new RegExp(`^(${SPDX_LICENSES.map(x => x.replaceAll(".", "\.")).join("|")})$`) -const nodePlatformPattern = new RegExp(`^(${NODE_PLATFORMS.join("|")})$`) -const nodeArchPattern = new RegExp(`^(${NODE_ARCHS.join("|")})$`) -const npmPersonPattern = new RegExp(`^\s*(?.+)\s*(?:<(?.+)>)?\s*(?:\((?.+)\))?\s*$`) - -export type NpmName = z.infer -export const NpmName = z.string() - .min(1, {message: "Cannot be empty"}) - .max(214, {message: "Cannot be longer than 214 characters"}) - .regex(/(?![A-Z])/g, {message: "Cannot have uppercase characters"}) - .regex(nonUrlSafePattern, {message: "Cannot contain non-url-safe characters"}) - .regex(/^(?!\.|_)/g, {message: "Cannot start with . or _"}) - .regex(/(?!\s)/g, {message: "Cannot contain spaces"}) - .regex(/(?!(\)|\()|\'|\!\*)/g, {message: "Cannot contain these characters: )('!*"}) - .regex(nonNpmBlacklistPattern, {message: "Cannot be 'node_modules' or 'favicon.ico'"}) - .regex(nonNodeBuiltinPattern, {message: "Cannot be a builtin node module name"}) - -export type SemVer = z.infer -export const SemVer = z.string() - .refine(x => semverValid(x), {message: "Invalid SemVer"}) - -export type SemVerRange = z.infer -export const SemVerRange = z.string() - .refine(x => semverValidRange(x), {message: "Invalid NPM version range"}) - -export type SpdxLicense = z.infer -export const SpdxLicense = z.string().regex(spdxLicensePattern, {message: "Is not a valid spdx license identifier"}) - -export type NodePlatform = z.infer -export const NodePlatform = z.string().regex(nodePlatformPattern, {message: "Is not a valid node platform (process.platform)"}) - -export type NodeArch = z.infer -export const NodeArch = z.string().regex(nodeArchPattern, {message: "Is not a valid node platform (process.arch)"}) - -const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]); -type Literal = z.infer; -export type Json = Literal | { [key: string]: Json } | Json[] | undefined -export const Json: z.ZodType = z.lazy(() => - z.union([literalSchema, Json.array(), z.record(Json)]) -); - -const PersonSchema = z - .object({ - name: z.string(), - email: z.string().email().optional(), - url: z.string().url().optional() - }) - -type ContentExpression = z.infer -const ContentExpression = z.string().superRefine((arg, ctx) => { - const words = [...arg.matchAll(/\w+/g)].map(match => match[0]) - const wordNodeSpecs = Object.fromEntries(words.map(word => [word, {}])) - const baseSchemaSpec = createSchemaSpec() - const schema = new Schema({ - ...baseSchemaSpec, - nodes: { - ...baseSchemaSpec.nodes, - ...wordNodeSpecs, - "_": {} - } - }) - try { - const argWithoutMIMEExprs = arg.replaceAll(/#\w+\/[-+.\w]+/g, "_") - // @ts-ignore: Using internal method from ProseMirror - ContentMatch.parse(argWithoutMIMEExprs, schema.nodes) - return arg - } - catch(err: any) { - ctx.addIssue({ - code: z.ZodIssueCode.custom, - message: err.message - }) - } -}) - -type Funding = z.infer -const Funding = z.object({ - type: z.string(), - url: z.string().url() -}) - -type IssueTracker = z.infer -const IssueTracker = z.object({ - url: z.string().url(), - email: z.string().email().optional() -}) -.or(z.object({ - url: z.string().url().optional(), - email: z.string().email() -})) - -type Repository = z.infer -const Repository = z.object({ - url: z.string().url(), - type: z.string() -}) -.or(z.string()) - -export type Person = z.infer -export const Person = z.string() - .regex(npmPersonPattern) - .transform(str => { - const groups = npmPersonPattern.exec(str)?.groups ?? {} - const {name, email, url} = groups - return {name, ...(email && {email}), ...(url && {url})} as z.infer - }) - .refine(arg => PersonSchema.parse(arg)) - .or(PersonSchema) - -export type EditingConfig = z.infer -export const EditingConfig = z.object({ - content: z - .record(z.string(), ContentExpression) - .or(ContentExpression.transform(arg => ({"": arg}))) - .default({}) - .optional(), -}) - -const PackageSchema = z.object({ - name: NpmName, - version: SemVer, - description: z.string().optional(), - keywords: z.array(z.string()).optional(), - homepage: z.string().url().optional(), - bugs: IssueTracker.optional(), - license: SpdxLicense.optional(), - author: Person.optional(), - contributors: Person.array().optional(), - funding: Funding.or(Funding.array()).optional(), - files: z.array(z.string()).optional(), - main: z.string().optional(), - browser: z.string().optional(), - bin: z.record(z.string()).optional(), - man: z.array(z.string()).optional(), - directories: z.record(z.string()).optional(), - repository: Repository.optional(), - scripts: z.record(z.string()).optional(), - dependencies: z.record(NpmName, SemVerRange).optional(), - devDependencies: z.record(NpmName, SemVerRange).optional(), - peerDependencies: z.record(NpmName, SemVerRange).optional(), - bundleDependencies: z.record(NpmName, SemVerRange).optional(), - optionalDependencies: z.record(NpmName, SemVerRange).optional(), - engines: z.record(z.string(), SemVerRange).optional(), - peerDependenciesMeta: z.record(NpmName, z.object({optional: z.boolean()})).optional(), - overrides: z.record(NpmName, z.string()).optional(), - os: NodePlatform.array().optional(), - arch: NodeArch.array().optional(), - private: z.boolean().optional(), - config: z.record(Json).optional(), - publishConfig: z.record(Json).optional(), - workspaces: z.string().array().optional(), - type: z.literal("commonjs").or(z.literal("module")).optional(), - exports: z - .string() - .or(z.string().array()) - .optional(), - imports: z.record(z.string().startsWith("#"), z.record(z.string())).optional(), - editingConfig: EditingConfig.optional() -}) -.catchall(Json) - -export type Package = z.infer -export const Package = Object.assign(PackageSchema, { - serialize(pkg: Package, format: "json" = "json") { - return JSON.stringify(pkg) - } -}) \ No newline at end of file diff --git a/@webwriter/core/model/schemas/packageschema/index.ts b/@webwriter/core/model/schemas/packageschema/index.ts new file mode 100644 index 00000000..ae7210b8 --- /dev/null +++ b/@webwriter/core/model/schemas/packageschema/index.ts @@ -0,0 +1,429 @@ +// @ts-strict +import {SafeParseReturnType, ZodSchema, z} from "zod" +import SPDX_LICENSE_MAP from "spdx-license-list" +import {valid as semverValid, validRange as semverValidRange} from "semver" + +import {ContentExpression, DataType} from ".." +import { filterObject } from "../../../utility" + +const SPDX_LICENSES = Object.keys(SPDX_LICENSE_MAP) +const NODE_BUILTINS = [ + 'assert', + 'buffer', + 'child_process', + 'cluster', + 'console', + 'constants', + 'crypto', + 'dgram', + 'dns', + 'domain', + 'events', + 'fs', + 'http', + 'https', + 'module', + 'net', + 'os', + 'path', + 'punycode', + 'querystring', + 'readline', + 'repl', + 'stream', + 'string_decoder', + 'sys', + 'timers', + 'tls', + 'tty', + 'url', + 'util', + 'vm', + 'zlib', + 'freelist', + 'v8', + 'process', + 'inspector', + 'async_hooks', + 'http2', + 'perf_hooks', + 'trace_events', + 'worker_threads', + 'node:test', + 'wasi', + 'diagnostics_channel' +] +const NODE_PLATFORMS = [ + 'aix', + 'darwin', + 'freebsd', + 'linux', + 'openbsd', + 'sunos', + 'win32' +] +const NODE_ARCHS = [ + 'arm', + 'arm64', + 'ia32', + 'mips', + 'mipsel', + 'ppc', + 'ppc64', + 's390', + 's390x', + 'x64' +] + +const RESERVED_CUSTOM_ELEMENT_NAMES = [ + "annotation-xml", + "color-profile", + "font-face", + "font-face-src", + "font-face-uri", + "font-face-format", + "font-face-name", + "missing-glyph" +] + +const nonUrlSafePattern = /(?!\{|\}|\||\\|\^|~|\[|\]|\`)/ +const nonNpmBlacklistPattern = /^(?!node_modules|favicon\.ico).+$/ +const nonNodeBuiltinPattern = new RegExp(`^(?!${NODE_BUILTINS.join("|")}).*$`) +const spdxLicensePattern = new RegExp(`^(${SPDX_LICENSES.map(x => x.replaceAll(".", "\.")).join("|")})$`) +const nodePlatformPattern = new RegExp(`^(${NODE_PLATFORMS.join("|")})$`) +const nodeArchPattern = new RegExp(`^(${NODE_ARCHS.join("|")})$`) +const npmPersonPattern = /^\s*(?.*?)\s*(?:<(?.+)>)?\s*(?:\((?.+)\))?\s*$/ +const mimePattern = /#?(?[\w!#$%&'*.^`|~-]+)(?:\/(?[\w!#$%&'*.^`|~-]+)(?:\+(?[\w!#$%&'*.^`|~-]+))?(?:;(?[\w!#$%&'*.^`|~-]+)=(?[\w!#$%&'*.^`|~-]+))?)?/ +const semverPattern = /(?0|[1-9]\d*)\.(?0|[1-9]\d*)\.(?0|[1-9]\d*)(?:-(?(?:0|[1-9]\d*|\d*[a-zA-Z\-][0-9a-zA-Z\-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z\-][0-9a-zA-Z\-]*))*))?(?:\+(?[0-9a-zA-Z\-]+(?:\.[0-9a-zA-Z\-]+)*))?/ +const npmNamePattern = /^(@[a-z0-9\-~][a-z0-9\-._~]*\/)?[a-z0-9\-~][a-z0-9\-._~]*$/ +const customElementNamePattern = /^[a-z][\w\d]*\-[\-.0-9_a-z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u10000-\uEFFFF]*$/ + +export type NpmName = z.infer +export const NpmName = z.string() + .min(1, {message: "Cannot be empty"}) + .max(214, {message: "Cannot be longer than 214 characters"}) + .regex(/(?![A-Z])/g, {message: "Cannot have uppercase characters"}) + .regex(nonUrlSafePattern, {message: "Cannot contain non-url-safe characters"}) + .regex(/^(?!\.|_)/g, {message: "Cannot start with . or _"}) + .regex(/(?!\s)/g, {message: "Cannot contain spaces"}) + .regex(/(?!(\)|\()|\'|\!\*)/g, {message: "Cannot contain these characters: )('!*"}) + .regex(nonNpmBlacklistPattern, {message: "Cannot be 'node_modules' or 'favicon.ico'"}) + .regex(nonNodeBuiltinPattern, {message: "Cannot be a builtin node module name"}) + + +const SemVerObjectSchema = z.object({ + major: z.number(), + minor: z.number(), + patch: z.number(), + prerelease: z.string().optional(), + buildmetadata: z.string().optional() +}) + +const SemVerSchema = z.string() + .transform((x, ctx) => { + const match = x.match(semverPattern) + if(match) { + const {major, minor, patch, prerelease, buildmetadata} = match.groups ?? {} + return {major: parseInt(major), minor: parseInt(minor), patch: parseInt(patch), prerelease, buildmetadata} + } + else { + ctx.addIssue({ + code: z.ZodIssueCode.custom, + message: `Invalid SemVer` + }) + return z.NEVER + } + }) + .pipe(SemVerObjectSchema) + .or(SemVerObjectSchema) + +export class SemVer extends DataType(SemVerSchema) { + serialize() { + const {major, minor, patch, prerelease, buildmetadata} = this + return `${major}.${minor}.${patch}${prerelease? `-${prerelease}`: ""}${buildmetadata? `+${buildmetadata}`: ""}` + } + + toString() { + return this.serialize() + } + + increment(key: "major" | "minor" | "patch", decrement=false) { + return new SemVer({ + ...this, + [key]: Math.max(0, this[key] + (decrement? -1: 1)) + }) + } +} + +export type SemVerRange = z.infer +export const SemVerRange = z.string() + .refine(x => semverValidRange(x), {message: "Invalid NPM version range"}) + + + +const LicenseObjectSchema = z.object({ + key: z.string(), + name: z.string().optional(), + url: z.string().url().optional(), + osiApproved: z.boolean().optional() +}) + +const LicenseSchema = (z + .string() + .transform((key, ctx) => { + if(!(key in SPDX_LICENSE_MAP)) { + // ctx.addIssue({code: z.ZodIssueCode.custom, message: "Not a valid SPDX license identifier"}) + return {key} as {key: string} + } + else { + return {...SPDX_LICENSE_MAP[key], key} + } + }) + .pipe(LicenseObjectSchema)) + .or(LicenseObjectSchema) + + + +export class License extends DataType(LicenseSchema) { + serialize() { + return this.key + } + + toString() { + return this.serialize() + } +} + +export type NodePlatform = z.infer +export const NodePlatform = z.string().regex(nodePlatformPattern, {message: "Is not a valid node platform (process.platform)"}) + +export type NodeArch = z.infer +export const NodeArch = z.string().regex(nodeArchPattern, {message: "Is not a valid node platform (process.arch)"}) + +const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null(), z.undefined()]); +type Literal = z.infer; +export type Json = Literal | { [key: string]: Json } | Json[] | undefined +export const Json: z.ZodType = z.lazy(() => + z.union([literalSchema, Json.array(), z.record(Json)]) +); + +const MIME_NAME_ENCODING = { + "~": "_".repeat(16), + "|": "_".repeat(15), + "`": "_".repeat(14), + "^": "_".repeat(13), + "*": "_".repeat(12), + "'": "_".repeat(11), + "&": "_".repeat(10), + "%": "_".repeat(9), + "$": "_".repeat(8), + "#": "_".repeat(7), + "!": "_".repeat(6), + ";": "_".repeat(5), + "/": "_".repeat(4), + ".": "_".repeat(3), + "+": "_".repeat(2), + "-": "_".repeat(1), +} + + +const MediaTypeSchema = z.string().transform((arg, ctx) => { + if(!arg.startsWith("_") && !arg.startsWith("#")) { + ctx.addIssue({ + code: z.ZodIssueCode.custom, + message: `MediaType must start with '#' or '_'` + }) + return z.NEVER + } + const value = arg.startsWith("_") + ? Object.entries(MIME_NAME_ENCODING).reduce((acc, [k, v]) => acc.replaceAll(v, k), arg) + : arg + const match = value.match(mimePattern) + if(match) { + const {supertype, subtype, suffix, pkey, pvalue} = match.groups ?? {} + return {supertype, subtype, suffix, ...(pkey? {[pkey]: pvalue}: null)} + } + else { + return z.NEVER + } +}) + +export class MediaType extends DataType(MediaTypeSchema) { + serialize(format: "expr" | "node" = "expr") { + if(format === "expr") { + const [paramKey, paramValue] = Object.entries(this).find(([k]) => k !== "supertype" && k !== "subtype") ?? [] + const paramStr = paramKey? `;${paramKey}=${paramValue}`: "" + return `#${this?.supertype}/${this?.subtype}` + paramStr + } + else { + return `_${this?.supertype}____${this.subtype.replaceAll("-", "_")}` + } + } + + toString() { + return this.serialize() + } +} + +type Funding = z.infer +const Funding = z.object({ + type: z.string(), + url: z.string().url() +}) + +type IssueTracker = z.infer +const IssueTracker = z.object({ + url: z.string().url(), + email: z.string().email().optional() +}) +.or(z.object({ + url: z.string().url().optional(), + email: z.string().email() +})) + +type Repository = z.infer +const Repository = z.object({ + url: z.string().url(), + type: z.string() +}) +.or(z.string()) + + +const PersonObjectSchema = z.object({ + name: z.string(), + email: z.string().optional(), + url: z.string().optional() +}) + +const PersonSchema = (z.string() + .regex(npmPersonPattern) + .transform(str => { + const groups = npmPersonPattern.exec(str)?.groups ?? {} + const {name, email, url} = groups + return {name, ...(email && {email}), ...(url && {url})} as z.infer + }) + .refine(arg => PersonObjectSchema.parse(arg))) + .or(PersonObjectSchema) + +export class Person extends DataType(PersonSchema) { + serialize() { + const email = this.email != null? ` <${this.email}>`: "" + const url = this.url != null? ` (${this.url})`: "" + return `${this.name}${email}${url}` + } + + toString() { + return this.serialize() + } + + extend(extraProperties: Partial) { + return new Person({...this, ...extraProperties}) + } +} + +export type EditingConfig = z.infer +export const EditingConfig = z.object({ + content: z + .record(z.string(), ContentExpression) + .or(ContentExpression.transform(arg => ({"": arg}))) + .default({}) + .optional(), +}) + +export type FileURL = z.infer +export const FileURL = z.string().url().startsWith("file") + +export type CustomElementName = z.infer +export const CustomElementName = z + .string() + .regex(customElementNamePattern) + .refine(x => !RESERVED_CUSTOM_ELEMENT_NAMES.includes(x)) + +const PackageSchema = z.object({ + name: NpmName, + version: SemVer.schema, + description: z.string().optional(), + keywords: z.array(z.string()).optional(), + homepage: z.string().url().optional(), + bugs: IssueTracker.optional(), + license: License.schema.optional(), + author: Person.schema.optional(), + contributors: Person.schema.array().optional(), + funding: Funding.or(Funding.array()).optional(), + files: z.array(z.string()).optional(), + main: z.string().optional(), + browser: z.string().optional(), + bin: z.record(z.string()).optional(), + man: z.array(z.string()).optional(), + directories: z.record(z.string()).optional(), + repository: Repository.optional(), + scripts: z.record(z.string()).optional(), + dependencies: z.record(NpmName, SemVerRange.or(FileURL)).optional(), + devDependencies: z.record(NpmName, SemVerRange.or(FileURL)).optional(), + peerDependencies: z.record(NpmName, SemVerRange.or(FileURL)).optional(), + bundleDependencies: z.record(NpmName, SemVerRange).or(FileURL).optional(), + optionalDependencies: z.record(NpmName, SemVerRange.or(FileURL)).optional(), + engines: z.record(z.string(), SemVerRange).optional(), + peerDependenciesMeta: z.record(NpmName, z.object({optional: z.boolean()})).optional(), + overrides: z.record(NpmName, z.string()).optional(), + os: NodePlatform.array().optional(), + arch: NodeArch.array().optional(), + private: z.boolean().optional(), + config: z.record(Json).optional(), + publishConfig: z.record(Json).optional(), + workspaces: z.string().array().optional(), + type: z.literal("commonjs").or(z.literal("module")).optional(), + exports: Json.optional(), + imports: z.record(z.string().startsWith("#"), z.record(z.string())).optional(), + editingConfig: EditingConfig.optional(), + installed: z.boolean().optional().default(false), + outdated: z.boolean().optional().default(false), + imported: z.boolean().optional().default(false), + watching: z.boolean().optional().default(false), + reloadCount: z.number().optional().default(0), + localPath: z.string().optional(), + importError: z.string().optional(), + jsSize: z.number().optional(), + cssSize: z.number().optional() +}) +.catchall(Json) + +export class Package extends DataType(PackageSchema) { + + static optionKeys = [ + "installed", + "outdated", + "imported", + "watching", + "reloadCount", + "localPath", + "importError", + "jsSize", + "cssSize" + ] + + serialize(format:"json"|"object"="json") { + const keys = Object.getOwnPropertyNames(this).filter(k => !Package.optionKeys.includes(k)) + const result = Object.fromEntries(keys.map(key => { + const value = (this as any)[key] + return [key, value] + })) + if(format === "json") { + return JSON.stringify(result, undefined, 4) + } + else { + return result + } + + } + + + + toString() { + return this.serialize() as string + } + + extend(extraProperties: Partial) { + return new Package({...this, ...extraProperties}) + } +} \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema.ts b/@webwriter/core/model/schemas/resourceschema.ts deleted file mode 100644 index e03e840e..00000000 --- a/@webwriter/core/model/schemas/resourceschema.ts +++ /dev/null @@ -1,591 +0,0 @@ -import {z} from "zod" -import {Schema, Node, NodeSpec, MarkSpec, Fragment, DOMSerializer} from "prosemirror-model" -import {Command, EditorState, EditorStateConfig, NodeSelection, TextSelection, Plugin, AllSelection} from "prosemirror-state" -import { baseKeymap} from "prosemirror-commands" -import {keymap} from "prosemirror-keymap" -import {inputRules, InputRule} from "prosemirror-inputrules" -import { history, undo, redo } from "prosemirror-history" -import { chainCommands, deleteSelection, joinBackward, selectNodeBackward} from "prosemirror-commands" -import { EditorView } from "prosemirror-view" -export {undo, redo} from "prosemirror-history" -import mime from "mime/lite" - -const MIME = Object.values((mime as any)._types) as string[] - -import { camelCaseToSpacedCase, filterObject, namedNodeMapToObject, unscopePackageName } from "../../utility" -import * as marshal from "../marshal" -import { PackageWithOptions } from "../stores" - -const leafNodeSpecs: Record = { - thematicBreak: {group: "leaf"} -} - -export function getOtherAttrsFromWidget(dom: HTMLElement) { - return Object.fromEntries(dom - .getAttributeNames() - .filter(name => !["editable", "printable", "analyzable", "contenteditable"].includes(name)) - .map(name => [name, dom.getAttribute(name)])) -} - -function slotContentNodeSpecName(packageName: string, slotName: string) { - return `${unscopePackageName(packageName).replace("-", "I")}_SLOT_${slotName}` -} - -function widgetSlotContent(pkg: PackageWithOptions) { - return Object.keys(pkg.editingConfig?.content ?? {}) - .map(name => slotContentNodeSpecName(pkg.name, name)) - .join(" ") -} - -function slotContentNodeSpec(pkg: PackageWithOptions, name: string, content: string): NodeSpec { - const nodeName = slotContentNodeSpecName(pkg.name, name) - return { - group: "_slotContent", - content, - toDOM: () => ["div", {class: nodeName + " slot-content", slot: name}, 0], - parseDOM: [{tag: `div.${nodeName}`}] - } -} - -function getMediaTypesOfContent(content: Record | undefined) { - if(content && "" in content) { - const expr = content[""] - const matches = [...expr.matchAll(/#\w+(?:\/[-+.\w]+)?/g)] - return matches.map(match => match[0].slice(1)) - } - else { - return [] - } -} - -function parseRuleOfMediaType(mediaType: string) { - -} - -function packageWidgetNodeSpec(pkg: PackageWithOptions): NodeSpec { - const maybeContent = pkg.editingConfig?.content - ? {content: widgetSlotContent(pkg)} - : undefined - const mediaTypes = getMediaTypesOfContent(pkg.editingConfig?.content) - const maybeMediaParseRules = mediaTypes.length > 0? [ - - ]: [] - - return { - group: "leaf", - widget: true, - package: pkg, - selectable: true, - draggable: false, - isolating: false, - ...maybeContent, - attrs: { - id: {}, - editable: {default: false}, - printable: {default: false}, - analyzable: {default: false}, - otherAttrs: {default: {}} - }, - parseDOM : [{tag: unscopePackageName(pkg.name), getAttrs: (dom: HTMLElement ) => { - return { - id: dom.getAttribute("id"), - editable: dom.getAttribute("editable") ?? false, - printable: dom.getAttribute("printable") ?? false, - analyzable: dom.getAttribute("analyzable") ?? false, - otherAttrs: Object.fromEntries(dom - .getAttributeNames() - .filter(name => !["editable", "printable", "analyzable"].includes(name)) - .map(name => [name, dom.getAttribute(name)])) - } - }}, ...maybeMediaParseRules] as any, - toDOM: (node: Node) => { - return [node.type.name, { - id: node.attrs.id, - ...(node.attrs.editable? {"editable": true}: {}), - ...(node.attrs.printable? {"printable": true}: {}), - ...(node.attrs.analyzable? {"analyzable": true}: {}), - ...node.attrs.otherAttrs, - "class": "ww-widget" - }].concat(pkg.editingConfig?.content? [0]: []) as any - } - } -} - -const inlineNodeSpecs: Record = { - text: { - group: "inline", - inline: true - }, - lineBreak: { - group: "inline", - inline: true, - parseDOM: [{"tag": "br"}], - toDOM: () => ["br"] - } -} - -function maybeChildNodeOutputSpec(node: Node, mediaType: string) { - const result: any[] = [] - const supertype = mediaType.split("/")[0] - if(supertype === "image") { - result.push(["img", {"src": node.attrs["src"], "data-type": mediaType}]) - } - else if(supertype === "audio" || supertype === "video") { - result.push(["source", {"src": node.attrs["src"], "type": mediaType}]) - } - return result -} - -const rootTags = { - "application": "script", - "audio": "audio", - "font": "script", - "image": "picture", - "model": "script", - "text": "script", - "video": "video" -} - -function detectMediaTypeFromDOM(dom: HTMLElement, rootTag: string) { - if(rootTag === "picture") { - return dom.querySelector("img")?.getAttribute("data-type") - } - else if(rootTag === "script") { - return dom.getAttribute("type") - } - else { - return dom.querySelector("source")?.getAttribute("type") - } -} - -function mediaNodeEntry(mediaType: string): [string, NodeSpec] { - const name = mediaType.replaceAll("/", "__").replaceAll("-", "_") - const supertype = mediaType.split("/")[0] as keyof typeof rootTags - const subtype = mediaType.split("/")[1] - - const rootTag = rootTags[supertype] - const rootAttrs = (node: Node) => rootTag === "script"? {src: node.attrs["src"], type: mediaType}: {controls: true} - - return [name, { - group: "_" + supertype, - attrs: { - src: {default: undefined} - }, - toDOM: node => [rootTag, rootAttrs(node), ...maybeChildNodeOutputSpec(node, mediaType)], - parseDOM: [{tag: rootTag, getAttrs: (dom: HTMLElement | string) => { - const detectedMediaType = detectMediaTypeFromDOM(dom as HTMLElement, rootTag) - console.log(detectedMediaType) - if(typeof dom === "string" || detectedMediaType !== mediaType) { - return false - } - else if(rootTag === "picture") { - const src = dom.querySelector("img")?.src - return !src? false: {src} - } - else if(rootTag === "audio" || rootTag === "video") { - const src = dom.querySelector("source")?.src - return !src? false: {src} - } - else { - console.log(dom) - const src = (dom as HTMLScriptElement)?.src - return !src? false: {src} - } - }}] - }] -} - - - -const mediaNodeSpecs = Object.fromEntries(MIME.map(mediaNodeEntry)) - - - -const containerNodeSpecs: Record = { - - paragraph: { - group: "container", - content: "inline*", - attrs: { - textAlign: {default: "left" as "left" | "center" | "right" | "justify"}, - lineHeight: {default: 1.25}, - marginTop: {default: 0}, - marginBottom: {default: "0.5rem"}, - marginLeft: {default: 0}, - marginRight: {default: 0} - }, - whitespace: "pre", - parseDOM: [{tag: "p"}], - toDOM: node => [ - "p", - { - style: Object.keys(node.attrs) - .map(key => `${camelCaseToSpacedCase(key, false, "-")}: ${String(node.attrs[key])}`).join("; ") - }, - 0 - ] - }, - - heading: { - group: "container", - content: "inline*", - attrs: {level: {default: 1}}, - defining: true, - parseDOM: [ - {tag: "h1", attrs: {level: 1}}, - {tag: "h2", attrs: {level: 2}}, - {tag: "h3", attrs: {level: 3}}, - {tag: "h4", attrs: {level: 4}}, - {tag: "h5", attrs: {level: 5}}, - {tag: "h6", attrs: {level: 6}}, - ], - toDOM: node => ["h" + node.attrs.level, 0] - }, - - list: { - group: "container", - content: "listItem+", - attrs: { - isOrdered: {default: false}, - order: {default: 1}, - tight: {default: false}}, - parseDOM: [{tag: "ol, ul", getAttrs: (dom: HTMLElement) => ({ - isOrdered: dom.tagName.toLowerCase() == "ol", - order: dom.hasAttribute("start")? + dom.getAttribute("start")!: 1, - tight: dom.hasAttribute("data-tight") - })}] as any, - toDOM: node => [node.attrs.isOrdered? "ol": "ul", { - start: node.attrs.order == 1? null: node.attrs.order, - "data-tight": node.attrs.tight? "true": null - }, 0] - }, - - listItem: { - group: "container", - content: "inline*", - defining: true, - parseDOM: [{tag: "li"}], - toDOM: () => ["li", 0] - }, -} - - - -const markSpecs: Record = { - bold: { - parseDOM: [{tag: "strong"}, {tag: "b"}], - toDOM: () => ["strong", 0] - }, - italic: { - parseDOM: [{tag: "em"}, {tag: "i"}], - toDOM: () => ["em", 0] - }, - strikethrough: { - parseDOM: [{tag: "s"}], - toDOM: () => ["s", 0] - }, - code: { - parseDOM: [{tag: "code"}], - toDOM: () => ["code", 0] - }, - underline: { - parseDOM: [ - {tag: "span", style: "text-decoration", getAttrs: (v: any) => v.includes && v.includes("underline")} - ], - toDOM: () => ["span", {style: "text-decoration: underline"}, 0] - }, - superscript: { - parseDOM: [{tag: "sup"}], - toDOM: () => ["sup", 0], - excludes: "subscript" - }, - subscript: { - parseDOM: [{tag: "sub"}], - toDOM: () => ["sub", 0], - excludes: "superscript" - }, - fontSize: { - attrs: { - value: {default: "12pt"} - }, - parseDOM: [{tag: "span", style: "font-size", getAttrs: (dom: string |HTMLElement) => ({ - value: (dom as HTMLElement).style.fontSize - })}], - toDOM: node => ["span", {style: `font-size: ${node.attrs.value}`}, 0] - }, - fontFamily: { - attrs: { - value: {default: "serif"} - }, - parseDOM: [{tag: "span", style: "font-family", getAttrs: (dom: string |HTMLElement) => ({ - value: (dom as HTMLElement).style.fontFamily - })}], - toDOM: node => ["span", {style: `font-family: ${node.attrs.value}`}, 0] - }, - link: { - attrs: { - href: {}, - title: {default: null} - }, - inclusive: true, - parseDOM: [{tag: "a[href]", getAttrs: (dom: HTMLElement) => ({ - href: dom.getAttribute("href"), - title: dom.getAttribute("title") - })}] as any, - toDOM: (mark, inline) => ["a", {href: mark.attrs.href}] - }, -} - -const UnknownElementSpec: NodeSpec = { - attrs: { - tagName: {}, - otherAttrs: {default: {}} - }, - parseDOM: [{ - tag: "*", - getAttrs: node => { - if(typeof node === "string" || !node.tagName.includes("-")) { - return false - } - else { - const tagName = node.tagName.toLowerCase() - return {tagName, otherAttrs: namedNodeMapToObject(node.attributes)} - } - }, - priority: 0 - }], - toDOM: node => [node.attrs.tagName, node.attrs.otherAttrs] -} - - -export const createSchemaSpec = (packages: PackageWithOptions[] = []) => { - const widgetNodes = Object.fromEntries(packages.map(pkg => [ - unscopePackageName(pkg.name), - packageWidgetNodeSpec(pkg) - ])) - const slotNodes = Object.fromEntries(packages.flatMap(pkg => { - const content = pkg.editingConfig?.content ?? {} - return Object.entries(content).map(([name, expr]) => [ - slotContentNodeSpecName(pkg.name, name), - slotContentNodeSpec(pkg, name, expr) - ]) - })) - return { - topNode: "explorable", - nodes: { - explorable: { - content: "paragraph+ ((leaf | container | _image | _audio | _video | _text | _application | _model) paragraph+)* paragraph*", - attrs: {meta: {default: {}}}, - parseDOM: [{tag: "body"}] - } as NodeSpec, - ...leafNodeSpecs, - ...inlineNodeSpecs, - ...containerNodeSpecs, - ...widgetNodes, - ...slotNodes, - ...mediaNodeSpecs, - unknownElement: UnknownElementSpec, - }, - marks: markSpecs - } -} - -export const baseSchema = new Schema(createSchemaSpec()) - - -const customBackspaceCommand = chainCommands( - deleteSelection, - (state, dispatch, view) => { - const nodeBefore = state.doc.resolve(state.selection.$from.before(1)).nodeBefore - if(!nodeBefore || !nodeBefore.type.spec["widget"]) { - return joinBackward(state, dispatch, view) - } - return false - }, - (state, dispatch, view) => { - const nodeBefore = state.doc.resolve(state.selection.$from.before(1)).nodeBefore - if(!nodeBefore || !nodeBefore.type.spec["widget"]) { - return selectNodeBackward(state, dispatch, view) - } - return false - } -) - -const customArrowCommand = (up=false) => chainCommands( - (state, dispatch, view) => { - const isWidgetNode = state.selection instanceof NodeSelection && state.selection.node.type.spec["widget"] as boolean - const hasParagraph = up - ? state.selection.$from.nodeBefore?.type.name === "paragraph" - : state.selection.$from.nodeAfter?.type.name === "paragraph" - if(isWidgetNode && !hasParagraph) { - const paragraph = state.schema.nodes.paragraph.create() - - const insertPos = up? state.selection.$from.pos: state.selection.$to.pos - let tr = state.tr.insert(insertPos, paragraph) - - const selectPos = up? tr.selection.$from.pos - 1: tr.selection.$to.pos + 1 - const selection = new TextSelection(tr.doc.resolve(selectPos)) - tr = tr.setSelection(selection) - dispatch? dispatch(tr): null - return true - } - else if(isWidgetNode && hasParagraph) { - const selectPos = up? state.selection.$from.pos - 1: state.selection.$to.pos + 1 - const selection = new TextSelection(state.doc.resolve(selectPos)) - const tr = state.tr.setSelection(selection) - dispatch? dispatch(tr): null - return true - } - else { - return false - } - - }, -) - -const customSelectAllCommand = () => chainCommands( - (state, dispatch, view) => { - let selection = new TextSelection(TextSelection.atStart(state.doc).$from, TextSelection.atEnd(state.doc).$to) - const tr = state.tr.setSelection(selection) - dispatch? dispatch(tr): null - return false - } -) - -/* -const customDeleteCommand = chainCommands( - (state, dispatch, view) => { - if(state.selection instanceof NodeSelection && state.selection.node.type.spec["widget"]) { - return state.tr. - } - }, - (state, dispatch, view) => { - return joinForward(state, dispatch, view) - }, - (state, dispatch, view) => { - return selectNodeForward(state, dispatch, view) - }, -) -*/ - -const explorableKeymap: Record = { - "Backspace": customBackspaceCommand, - "Control-ArrowUp": customArrowCommand(true), - "Control-ArrowDown": customArrowCommand(), - "Control-a": customSelectAllCommand() -} - -const rules: InputRule[] = [ -// new InputRule(/^#{1,6} $/, "heading"), -// new InputRule(/\*\*.$/, "bold"), -// new InputRule(/\*.$/, "italic"), - new InputRule(/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$/, (state, match, start, end) => { - const href = match[0] - const linkMark = state.schema.mark("link", {href}) - const textNode = state.schema.text(href, [linkMark]) - return state.tr.replaceRangeWith(start, end, textNode) - }) -] - -export function isEmpty(attributeKey: string = "data-empty") { - const update = (view: EditorView) => { - if (view.state.doc.textContent || view.state.doc.childCount > 1 || view.state.doc?.firstChild?.type?.name !== "paragraph") { - view.dom.removeAttribute(attributeKey); - } else { - view.dom.setAttribute(attributeKey, ""); - } - }; - - return new Plugin({ - view(view) { - update(view); - return { update }; - } - }); -} - -export const defaultConfig: EditorStateConfig & {schema: Schema, doc: Node} = { - schema: baseSchema, - doc: baseSchema.node(baseSchema.topNodeType, {}, [baseSchema.node("paragraph")]), - plugins: [ - keymap({...baseKeymap, ...explorableKeymap}), - inputRules({rules}), - history(), - isEmpty(), - ] -} - -export function createEditorStateConfig(packages: PackageWithOptions[]) { - return { - schema: new Schema(createSchemaSpec(packages)), - doc: baseSchema.node(baseSchema.topNodeType, {}, [baseSchema.node("paragraph")]), - plugins: [ - keymap({...baseKeymap, ...explorableKeymap}), - inputRules({rules}), - history(), - isEmpty() - ] - } -} - -export function createSchema(packages: PackageWithOptions[]) { - return new Schema(createSchemaSpec(packages)) -} - -/* -export const createEditorState2 = ( - {packages = [], baseConfig = defaultConfig, schema, doc} - : {packages?: string[], baseConfig?: EditorStateConfig, schema?: Schema, doc?: Node}) => { - const activeSchema = schema? schema: new Schema(createSchemaSpec(packages)) - const resolvedDoc = doc ?? activeSchema.node( - defaultConfig.doc.type.name, - defaultConfig.doc.attrs, - Fragment.fromJSON(activeSchema, defaultConfig.doc.content.toJSON()), - defaultConfig.doc.marks - ) ?? baseConfig.doc - return EditorState.create({ - doc: resolvedDoc, - selection: baseConfig.selection, - storedMarks: baseConfig.storedMarks, - plugins: baseConfig.plugins, - }) -} -*/ - -export const createEditorState = ({schema=defaultConfig.schema, doc=defaultConfig.doc, selection=defaultConfig.selection, storedMarks=defaultConfig.storedMarks, plugins=defaultConfig.plugins}: EditorStateConfig) => { - const resolvedDoc = schema.nodeFromJSON(doc.toJSON()) - return EditorState.create({schema, selection, storedMarks, plugins, doc: resolvedDoc}) -} - - -type Format = keyof typeof marshal - -const ResourceSchema = z.object({ - url: z.string().url({message: "Not a valid URL"}), - editorState: z - .instanceof(EditorState) - .or( - z.object({ - value: z.any(), - schema: z.instanceof(Schema) - }) - .transform(async ({value, schema}) => { - for(const parse of Object.values(marshal).map(({parse}) => parse)) { - try { - return await parse(value, schema) - } - catch(e) { - return z.NEVER - } - } - return z.NEVER - }) - ) -}) - -export type Resource = z.infer -export const Resource = Object.assign(ResourceSchema, { - serialize(resource: Resource, format: Format = "html", bundle: any) { - return marshal[format].serialize(resource.editorState.doc, bundle) - } -}) \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema/commands.ts b/@webwriter/core/model/schemas/resourceschema/commands.ts new file mode 100644 index 00000000..6fabecd8 --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/commands.ts @@ -0,0 +1,171 @@ +import { chainCommands, deleteSelection, joinBackward, selectNodeBackward } from "prosemirror-commands" +import { EditorState, NodeSelection, TextSelection } from "prosemirror-state" +import {Node, NodeType, Attrs, Slice, Fragment} from "prosemirror-model" + +import { camelCaseToSpacedCase, filterObject, getMatchedCSSRules, range } from "../../../utility" +import { getActiveMarks, fitIntoNode } from "./helpers" +import { fixTables } from "prosemirror-tables" +import { ProsemirrorEditor } from "../../../view" +import { styleAttrs } from "./nodes" + + +export const customBackspaceCommand = chainCommands( + deleteSelection, + (state, dispatch, view) => { + const nodeBefore = state.doc.resolve(state.selection.$from.before(1)).nodeBefore + if(!nodeBefore || !nodeBefore.type.spec["widget"]) { + return joinBackward(state, dispatch, view) + } + return false + }, + (state, dispatch, view) => { + const nodeBefore = state.doc.resolve(state.selection.$from.before(1)).nodeBefore + if(!nodeBefore || !nodeBefore.type.spec["widget"]) { + return selectNodeBackward(state, dispatch, view) + } + return false + } +) + +export const customArrowCommand = (up=false) => chainCommands( + (state, dispatch, view) => { + const isWidgetNode = state.selection instanceof NodeSelection && state.selection.node.type.spec["widget"] as boolean + const hasParagraph = up + ? state.selection.$from.nodeBefore?.type.name === "paragraph" + : state.selection.$from.nodeAfter?.type.name === "paragraph" + if(isWidgetNode && !hasParagraph) { + const paragraph = state.schema.nodes.paragraph.create() + + const insertPos = up? state.selection.$from.pos: state.selection.$to.pos + let tr = state.tr.insert(insertPos, paragraph) + + const selectPos = up? tr.selection.$from.pos - 1: tr.selection.$to.pos + 1 + const selection = new TextSelection(tr.doc.resolve(selectPos)) + tr = tr.setSelection(selection) + dispatch? dispatch(tr): null + return true + } + else if(isWidgetNode && hasParagraph) { + const selectPos = up? state.selection.$from.pos - 1: state.selection.$to.pos + 1 + const selection = new TextSelection(state.doc.resolve(selectPos)) + const tr = state.tr.setSelection(selection) + dispatch? dispatch(tr): null + return true + } + else { + return false + } + + }, +) + +export const customSelectAllCommand = () => chainCommands( + (state, dispatch, view) => { + let selection = new TextSelection(TextSelection.atStart(state.doc).$from, TextSelection.atEnd(state.doc).$to) + const tr = state.tr.setSelection(selection) + dispatch? dispatch(tr): null + return false + } +) + +/* +const customDeleteCommand = chainCommands( + (state, dispatch, view) => { + if(state.selection instanceof NodeSelection && state.selection.node.type.spec["widget"]) { + return state.tr. + } + }, + (state, dispatch, view) => { + return joinForward(state, dispatch, view) + }, + (state, dispatch, view) => { + return selectNodeForward(state, dispatch, view) + }, +) +*/ + +export function toggleOrUpdateMark(mark: string, attrs: any = {}) { + return (state: EditorState, dispatch: any) => { + const {from, to} = state.selection + const markType = state.schema.marks[mark] + const newMark = markType.create(attrs) + const correspondingMark = getActiveMarks(state).find(m => m.type.name === mark) + if(!correspondingMark || !correspondingMark?.eq(newMark)) { + return dispatch(state.tr + .removeMark(from, to, markType) + .addMark(from, to, newMark) + ) + } + else { + return dispatch(state.tr.removeMark(from, to, markType)) + } + } +} + +export function setAttributeOnSelectedBlocks(key: string, value: any) { + return (state: EditorState, dispatch: any, view: ProsemirrorEditor) => { + if(state.selection instanceof TextSelection) { + const selectedBlocksPos = new Set([ + state.selection.$from.before(1) + ]) + + state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos, parent, index) => { + console.log(node) + if(node.type.isBlock) { + selectedBlocksPos.add(pos) + } + }) + + const tr = [...selectedBlocksPos].reduce((tr, pos) => { + return tr.setNodeAttribute(pos, key, value) + }, state.tr) + return dispatch(tr) + } + else { + return false + } + } +} + +export function wrapSelection(type: string | NodeType, attrs?: Attrs) { + return chainCommands((state: EditorState, dispatch: any) => { + const {selection} = state + const nodeType = typeof type === "string"? state.schema.nodes[type]: type + let from: number, to: number, slice: Slice + if(!(selection instanceof TextSelection)) { + return false + } + else if(!selection.empty) { + from = selection.from + to = selection.to + slice = selection.content() + } + else { + from = selection.$cursor?.before(1)! + to = selection.$cursor?.after(1)! + const wrappingSelection = TextSelection.create(state.doc, from, to) + slice = wrappingSelection.content() + } + let content = [] as Node[] + const n = slice.content.childCount + range(n).forEach(i => content.push(slice.content.child(i))) + const newNode = fitIntoNode(nodeType.create(attrs)!, content) + console.log(newNode) + let newStart: number | null = null + let newEnd: number | null = null + let tr = state.tr.replaceRangeWith(from, to, newNode) + tr.doc.nodesBetween(0, tr.doc.content.size - 1, (node, start) => { + if(node === newNode) { + newStart = start + newEnd = start + node.content.size + 1 + } + }) + if(newStart !== null && newEnd !== null) { + // tr = tr.setSelection(new TextSelection(tr.doc.resolve(newStart), tr.doc.resolve(newEnd))) + const s = new NodeSelection(tr.doc.resolve(newStart)) + tr = tr.setSelection(new TextSelection(s.$from, s.$to)) + } + return dispatch(tr) + } + ) +} diff --git a/@webwriter/core/model/schemas/resourceschema/helpers.ts b/@webwriter/core/model/schemas/resourceschema/helpers.ts new file mode 100644 index 00000000..61b5c7cf --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/helpers.ts @@ -0,0 +1,185 @@ +import { EditorState, TextSelection} from "prosemirror-state" +import {Node, NodeType, Attrs, Fragment, Schema} from "prosemirror-model" + +import { ContentExpression, ParentedExpression, styleAttrs } from ".." +import {camelCaseToSpacedCase, range, shallowCompare} from "../../../utility" +import { EditorView } from "prosemirror-view" +import { ProsemirrorEditor } from "../../../view" + + +export const INDETERMINATE_VALUE = Symbol("INDETERMINATE_VALUE") + +export function createWidget(schema: Schema, name: string, id: string, editable=true) { + const nodeType = schema.nodes[name] + return nodeType.createAndFill({id, otherAttrs: {editable}}, []) +} + + +export function getActiveMarks(state: EditorState, includeStored=true) { + const stored = state.storedMarks ?? [] + const marks = new Set(includeStored? stored: []) + state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos, parent, index) => { + node.marks.forEach(mark => marks.add(mark)) + }) + return Array.from(marks) +} + +export function getActiveAttributes(state: EditorState, key: string) { + const attributes = new Set([ + state.selection.$from.node(1)?.attrs[key] + ]) + state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos, parent, index) => { + attributes.add(node.attrs[key]) + }) + return Array.from(attributes).filter(attr => attr) +} + +export function getActiveBlockAttributes(state: EditorState, view: ProsemirrorEditor) { + const attributes = {} as Record + state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos) => { + if(node.type.isBlock) { + const dom = view?.nodeDOM(pos) as Element + Object.keys(node.attrs).forEach(key => { + const kebabKey = camelCaseToSpacedCase(key, false, "-") + const value = node.attrs[key] + const fallbackValue = key in Object.keys(styleAttrs) + ? view.window.getComputedStyle(dom).getPropertyValue(kebabKey) + : undefined + attributes[key] = { + ...attributes[key], + value: attributes[key]?.value !== undefined? null: value, + fallbackValue: fallbackValue? fallbackValue: attributes[key]?.fallbackValue + } + }) + } + }) + return attributes +} + +export function getActiveNodeNames(state: EditorState | undefined) { + const nodeNames = [] as string[] + if(state) { + state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos, parent, index) => { + nodeNames.push(node.type.name) + }) + } + return nodeNames +} + +export function hasActiveNode(state: EditorState | undefined, type: string | NodeType, attrs?: Attrs, includeAncestors=false) { + let matchFound = false + if(state) { + state.doc.nodesBetween(state.selection.from, state.selection.to, node => { + const typeMatches = typeof type === "string"? node.type.name === type: node.type === type + const attrsMatches = !attrs || Object.keys(attrs).every(k => attrs[k] === node.attrs[k]) + if(typeMatches && attrsMatches) { + matchFound = true + } + }) + if(includeAncestors) { + const resolvedPos = state.selection.$anchor + const ancestors = range(0, resolvedPos.depth).map(i => resolvedPos.node(i)) + } + } + return matchFound +} + +export function nestNodes(nodes: Node[]): Node { + return nodes.reduceRight((acc, node) => node.copy(Fragment.fromArray([acc]))) +} + +/** + * Try to fit `content` into `node`. + * For each content node, DFS until content node fits + */ +export function fitIntoNode(node: Node, content: Node[]): Node { + const {type} = node + const newContent = [] as Node[] + if(type.spec.content) { + const expression = ContentExpression.parse(type.spec.content) + const tree = ContentExpression.resolve(type.schema, expression) + const values = ContentExpression.values(tree) + const contentPaths = [] as Node[][] + const fragment = Fragment.fromArray(content) + fragment.descendants(contentNode => { + for(const [i, value] of values.entries()) { + if(value.type === "NodeExpression" && (contentNode.type.name === value?.node)) { + const childPath = [] + let activeValue: ParentedExpression = value + while(activeValue.parent) { + if(activeValue.parent!.type === "NodeExpression") { + childPath.unshift(activeValue.parent) + } + activeValue = activeValue.parent + } + const contentPath = [ + ...childPath.map(e => type.schema.nodes[e.node].create()), + contentNode + ] + contentPaths.push(contentPath) + return false + } + } + }) + contentPaths.forEach(cp => newContent.push(nestNodes(cp))) + } + console.log(newContent) + return newContent && newContent.length > 0 + ? node.copy(Fragment.fromArray(newContent)) + : fillNode(node.type, node.attrs) +} + +export function fillNode(type: NodeType, attrs?: Attrs): Node { + const node = type.createAndFill(attrs)! + let content = Fragment.fromArray([]) + node.content?.forEach(node => { + content = content.addToEnd(fillNode(node.type)) + }) + return node.copy(content) +} + +export function getDocAttribute(state: EditorState, key: string, asArray=true): string { + const attr = state.doc.attrs.meta[key] + return attr == null || Array.isArray(attr) || !asArray? attr: [attr] +} + +export function getComputedStyleObject(element: Element) { + const computedStyles = {} as Record + const computedDeclaration = getComputedStyle(element) + for(let i = 0; i < computedDeclaration.length; i++) { + const key = computedDeclaration.item(i) + const value = computedDeclaration.getPropertyValue(key) + computedStyles[key] = value + } + return computedStyles +} + +export function getSelectedDom(state: EditorState, view: EditorView) { + const selectedPos = new Set([ + state.selection.$from.before(1) + ]) + + state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos, parent, index) => { + selectedPos.add(pos) + }) + return [...selectedPos].map(pos => view.nodeDOM(pos)!) +} + +export function getStyleValues(state: EditorState, view: EditorView & {window: Window}, key: string) { + const values = new Set() + const kebabKey = camelCaseToSpacedCase(key, false, "-") + state.selection.content().content.descendants((node, pos, parent) => { + const dom = view.nodeDOM(pos) + if(dom instanceof Element) { + const computed = view.window.getComputedStyle(dom).getPropertyValue(kebabKey) + values.add(computed) + } + }) + const beforeDom = view.nodeDOM(state.selection.$from.before(1)) + if(beforeDom instanceof Element) { + const beforeComputed = view.window.getComputedStyle(beforeDom).getPropertyValue(kebabKey) + values.add(beforeComputed) + } + + return [...values] +} \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema/index.ts b/@webwriter/core/model/schemas/resourceschema/index.ts new file mode 100644 index 00000000..b665b39b --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/index.ts @@ -0,0 +1,168 @@ +import {z} from "zod" +import {Schema, Node} from "prosemirror-model" +import {Command, EditorState, EditorStateConfig, Plugin} from "prosemirror-state" +import { baseKeymap, chainCommands, createParagraphNear, liftEmptyBlock, newlineInCode, splitBlock} from "prosemirror-commands" +import {keymap} from "prosemirror-keymap" +import {inputRules, InputRule} from "prosemirror-inputrules" +import { history } from "prosemirror-history" +import { EditorView } from "prosemirror-view" +export {undo, redo} from "prosemirror-history" +import { gapCursor } from "prosemirror-gapcursor" +import { tableEditing, columnResizing } from "prosemirror-tables" +import { liftListItem, sinkListItem, splitListItem } from "prosemirror-schema-list" + + +import { unscopePackageName } from "../../../utility" +import * as marshal from "../../marshal" +import { Package } from "../.." +import {containerNodes, inlineNodes, leafNodes, explorable} from "./nodes" +import {marks} from "./marks" +import { mediaNodeSpecs } from "./media" +import { packageWidgetNodeSpec, slotContentNodeSpec, slotContentNodeSpecName } from "./widgets" +import {customArrowCommand, customBackspaceCommand, customSelectAllCommand} from "./commands" + + +export const createBaseSchemaSpec = () => { + return {topNode: "explorable", nodes: {explorable, ...containerNodes, ...inlineNodes, ...leafNodes}, marks} +} + +export const createSchemaSpec = (packages: Package[] = []) => { + const widgetNodes = Object.fromEntries(packages.map(pkg => [ + unscopePackageName(pkg.name), + packageWidgetNodeSpec(pkg) + ])) + const slotNodes = Object.fromEntries(packages.flatMap(pkg => { + const content = pkg.editingConfig?.content ?? {} + return Object.entries(content).map(([name, expr]) => [ + slotContentNodeSpecName(pkg.name, name), + slotContentNodeSpec(pkg, name, expr.raw!) + ]) + })) + const baseSpec = createBaseSchemaSpec() + const spec = { + ...baseSpec, + nodes: { + ...baseSpec.nodes, + ...widgetNodes, + ...slotNodes, + ...mediaNodeSpecs, + } + } + return spec +} + +export const baseSchema = new Schema(createBaseSchemaSpec()) + +const explorableKeymap: Record = { + "Backspace": customBackspaceCommand, + "Control-ArrowUp": customArrowCommand(true), + "Control-ArrowDown": customArrowCommand(), + "Enter": chainCommands(splitListItem(baseSchema.nodes["listItem"]), newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock), + "Tab": sinkListItem(baseSchema.nodes["listItem"]), + "Shift-Tab": liftListItem(baseSchema.nodes["listItem"]), + //"Control-a": customSelectAllCommand() +} + +const rules: InputRule[] = [ +// new InputRule(/^#{1,6} $/, "heading"), +// new InputRule(/\*\*.$/, "bold"), +// new InputRule(/\*.$/, "italic"), + new InputRule(/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$/, (state, match, start, end) => { + const href = match[0] + const linkMark = state.schema.mark("link", {href}) + const textNode = state.schema.text(href, [linkMark]) + return state.tr.replaceRangeWith(start, end, textNode) + }) +] + +export function isEmpty(attributeKey: string = "data-empty") { + const update = (view: EditorView) => { + if (view.state.doc.textContent || view.state.doc.childCount > 1 || view.state.doc?.firstChild?.type?.name !== "paragraph") { + view.dom.removeAttribute(attributeKey); + } else { + view.dom.setAttribute(attributeKey, ""); + } + }; + + return new Plugin({ + view(view) { + update(view); + return { update }; + } + }); +} + +export const defaultConfig: EditorStateConfig & {schema: Schema, doc: Node} = { + schema: baseSchema, + doc: baseSchema.node(baseSchema.topNodeType, {}, [baseSchema.node("paragraph")]), + plugins: [ + keymap({...baseKeymap, ...explorableKeymap}), + inputRules({rules}), + history(), + isEmpty(), + gapCursor(), + tableEditing(), + ] +} + +export function createEditorStateConfig(packages: Package[]) { + return { + schema: new Schema(createSchemaSpec(packages)), + doc: baseSchema.node(baseSchema.topNodeType, {}, [baseSchema.node("paragraph")]), + plugins: [ + keymap({...baseKeymap, ...explorableKeymap}), + inputRules({rules}), + history(), + isEmpty() + ] + } +} + +export function createSchema(packages: Package[]) { + return new Schema(createSchemaSpec(packages)) +} + +export const createEditorState = ({schema=defaultConfig.schema, doc=defaultConfig.doc, selection=defaultConfig.selection, storedMarks=defaultConfig.storedMarks, plugins=defaultConfig.plugins}: EditorStateConfig) => { + const resolvedDoc = schema.nodeFromJSON(doc.toJSON()) + return EditorState.create({selection, storedMarks, plugins, doc: resolvedDoc}) +} + + +type Format = keyof typeof marshal + +const ResourceSchema = z.object({ + url: z.string().url({message: "Not a valid URL"}), + editorState: z + .instanceof(EditorState) + .or( + z.object({ + value: z.any(), + schema: z.instanceof(Schema) + }) + .transform(async ({value, schema}) => { + for(const parse of Object.values(marshal).map(({parse}) => parse)) { + try { + return await parse(value, schema) + } + catch(e) { + return z.NEVER + } + } + return z.NEVER + }) + ) +}) + +export type Resource = z.infer +export const Resource = Object.assign(ResourceSchema, { + serialize(resource: Resource, format: Format = "html", bundle: any) { + return marshal[format].serialize(resource.editorState.doc, bundle) + } +}) + +export * from "./helpers" +export * from "./marks" +export * from "./media" +export * from "./nodes" +export * from "./widgets" +export * from "./commands" \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema/marks.ts b/@webwriter/core/model/schemas/resourceschema/marks.ts new file mode 100644 index 00000000..4133581e --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/marks.ts @@ -0,0 +1,84 @@ +import {MarkSpec} from "prosemirror-model" + +export const marks: Record = { + bold: { + parseDOM: [{tag: "strong"}, {tag: "b"}], + toDOM: () => ["strong", 0] + }, + italic: { + parseDOM: [{tag: "em"}, {tag: "i"}], + toDOM: () => ["em", 0] + }, + strikethrough: { + parseDOM: [{tag: "s"}], + toDOM: () => ["s", 0] + }, + code: { + parseDOM: [{tag: "code"}], + toDOM: () => ["code", 0] + }, + underline: { + parseDOM: [ + {tag: "span", style: "text-decoration", getAttrs: (v: any) => v.includes && v.includes("underline")} + ], + toDOM: () => ["span", {style: "text-decoration: underline"}, 0] + }, + superscript: { + parseDOM: [{tag: "sup"}], + toDOM: () => ["sup", 0], + excludes: "subscript" + }, + subscript: { + parseDOM: [{tag: "sub"}], + toDOM: () => ["sub", 0], + excludes: "superscript" + }, + fontSize: { + attrs: { + value: {default: "12pt"} + }, + parseDOM: [{tag: "span", style: "font-size", getAttrs: (dom: string |HTMLElement) => ({ + value: (dom as HTMLElement).style.fontSize + })}], + toDOM: node => ["span", {style: `font-size: ${node.attrs.value}`}, 0] + }, + fontFamily: { + attrs: { + value: {default: "serif"} + }, + parseDOM: [{tag: "span", style: "font-family", getAttrs: (dom: string |HTMLElement) => ({ + value: (dom as HTMLElement).style.fontFamily + })}], + toDOM: node => ["span", {style: `font-family: ${node.attrs.value}`}, 0] + }, + link: { + attrs: { + href: {default: ""}, + title: {default: null} + }, + inclusive: true, + parseDOM: [{tag: "a[href]", getAttrs: (dom: HTMLElement) => ({ + href: dom.getAttribute("href"), + title: dom.getAttribute("title") + })}] as any, + toDOM: (mark, inline) => ["a", {href: mark.attrs.href}] + }, + textBackground: { + attrs: { + color: {default: "#fff000"} + }, + parseDOM: [{tag: "span", getAttrs: (dom: HTMLElement | string) => ({ + color: (dom as HTMLElement).style.backgroundColor + })}], + toDOM: node => ["span", {style: `background-color: ${node.attrs.color}`}, 0], + }, + textColor: { + attrs: { + value: {default: "unset"} + }, + parseDOM: [{tag: "span", style: "color", getAttrs: (dom: string |HTMLElement) => ({ + value: (dom as HTMLElement).style.color + })}], + toDOM: node => ["span", {style: `color: ${node.attrs.value}`}, 0] + }, +} \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema/media.ts b/@webwriter/core/model/schemas/resourceschema/media.ts new file mode 100644 index 00000000..deba4c01 --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/media.ts @@ -0,0 +1,81 @@ +import mime from "mime/lite" +import {Node, NodeSpec} from "prosemirror-model" + +import { MediaType } from "../packageschema" + +const MIME = Object.values((mime as any)._types) as string[] + +function maybeChildNodeOutputSpec(node: Node, mediaType: string) { + const result: any[] = [] + const supertype = mediaType.split("/")[0] + if(supertype === "image") { + result.push(["img", {"src": node.attrs["src"], "data-type": mediaType}]) + } + else if(supertype === "audio" || supertype === "video") { + result.push(["source", {"src": node.attrs["src"], "type": mediaType}]) + } + return result +} + +const rootTags = { + "application/pdf": "embed", + "application": "script", + "audio": "audio", + "font": "script", + "image": "picture", + "model": "script", + "text": "script", + "video": "video" +} + +function detectMediaTypeFromDOM(dom: HTMLElement, rootTag: string) { + if(rootTag === "picture") { + return dom.querySelector("img")?.getAttribute("data-type") + } + else if(rootTag === "script" || rootTag === "embed") { + return dom.getAttribute("type") + } + else { + return dom.querySelector("source")?.getAttribute("type") + } +} + +function mediaNodeEntry(mediaType: string): [string, NodeSpec] { + const parsed = new MediaType(mediaType) + const supertype = parsed.supertype as keyof typeof rootTags + const subtype = parsed.subtype + + const rootTag = rootTags[mediaType as keyof typeof rootTags] ?? rootTags[supertype] + const rootAttrs = (node: Node) => rootTag === "script" || rootTag === "embed"? {src: node.attrs["src"], type: mediaType}: {controls: true} + + return [parsed.serialize("node"), { + group: "_" + supertype, + attrs: { + src: {default: undefined} + }, + toDOM: node => [rootTag, rootAttrs(node), ...maybeChildNodeOutputSpec(node, mediaType)], + parseDOM: [{tag: rootTag, getAttrs: (dom: HTMLElement | string) => { + const detectedMediaType = detectMediaTypeFromDOM(dom as HTMLElement, rootTag) + if(typeof dom === "string" || detectedMediaType !== mediaType) { + return false + } + else if(rootTag === "picture") { + const src = dom.querySelector("img")?.src + return !src? false: {src} + } + else if(rootTag === "audio" || rootTag === "video") { + const src = dom.querySelector("source")?.src + return !src? false: {src} + } + else { + const src = (dom as HTMLScriptElement | HTMLEmbedElement)?.src + return !src? false: {src} + } + }}] + }] +} + +export const mediaNodeSpecs = Object.fromEntries(MIME + .map(mediaType => `#${mediaType}`) + .map(mediaNodeEntry) +) \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema/nodes.ts b/@webwriter/core/model/schemas/resourceschema/nodes.ts new file mode 100644 index 00000000..36bc27c3 --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/nodes.ts @@ -0,0 +1,221 @@ +import { tableNodes as createTableNodes } from "prosemirror-tables" +import {NodeSpec, Attrs} from "prosemirror-model" +import {bulletList, orderedList, listItem} from "prosemirror-schema-list" + +import { camelCaseToSpacedCase, namedNodeMapToObject } from "../../../utility" + + +export const styleAttrs = { + textAlign: {default: null}, + lineHeight: {default: null}, + marginTop: {default: null}, + marginBottom: {default: null}, + marginLeft: {default: null}, + marginRight: {default: null}, + paddingTop: {default: null}, + paddingBottom: {default: null}, + paddingLeft: {default: null}, + paddingRight: {default: null}, + borderTop: {default: null}, + borderBottom: {default: null}, + borderLeft: {default: null}, + borderRight: {default: null}, + background: {default: null}, +} + +export function serializeStyleAttrs(attrs: Attrs) { + return Object.keys(attrs) + .filter(key => (key in styleAttrs) && attrs[key]) + .map(key => `${camelCaseToSpacedCase(key, false, "-")}: ${attrs[key]}`) + .join("; ") +} + +export function parseStyleAttrs(dom: HTMLElement | string) { + console.log(typeof dom === "string" + ? {} as Record + : Object.fromEntries(Object.keys(styleAttrs) + .map(k => [k, dom.style[k as keyof typeof dom.style]]) + .filter(([k, v]) => v) + ) as Record) + return typeof dom === "string" + ? {} as Record + : Object.fromEntries(Object.keys(styleAttrs) + .map(k => [k, dom.style[k as keyof typeof dom.style]]) + .filter(([k, v]) => v) + ) as Record +} + +export type LeafNodeSpec = NodeSpec & {group: "leaf"} + + +export const explorable: NodeSpec = { + content: "container+ ((leaf | container) container+)* container*", + attrs: {meta: {default: {}}}, + parseDOM: [{tag: "body"}] +} + +export const leafNodes: Record = { + thematicBreak: { + group: "leaf" + } +} + +export type InlineNodeSpec = NodeSpec & {group: "inline", inline: true} + +export const inlineNodes: Record = { + text: { + group: "inline", + inline: true + }, + lineBreak: { + group: "inline", + inline: true, + parseDOM: [{"tag": "br"}], + toDOM: () => ["br"] + } +} + + +let tableNodes = createTableNodes({ + tableGroup: "container", + cellContent: "inline*", + cellAttributes: {} +}) +tableNodes = { + ...tableNodes, + "table_row": { + ...tableNodes["table_row"], + content: "(table_cell | table_header)+" + } +} + +export type ContainerNodeSpec = NodeSpec & {group: "container", content: string} | typeof tableNodes + +export const containerNodes: Record = { + paragraph: { + group: "container", + content: "inline*", + attrs: {...styleAttrs}, + whitespace: "pre", + parseDOM: [{tag: "p", getAttrs: parseStyleAttrs}], + toDOM: node => [ + "p", + { + style: serializeStyleAttrs(node.attrs) + }, + 0 + ] + }, + + blockquote: { + group: "container", + content: "inline*", + attrs: {...styleAttrs}, + whitespace: "pre", + parseDOM: [{tag: "blockquote", getAttrs: parseStyleAttrs}], + toDOM: node => [ + "blockquote", + { + style: serializeStyleAttrs(node.attrs) + }, + 0 + ] + }, + + heading: { + group: "container", + content: "inline*", + attrs: {level: {default: 1}, ...styleAttrs}, + defining: true, + parseDOM: [ + {tag: "h1", attrs: {level: 1}, getAttrs: parseStyleAttrs}, + {tag: "h2", attrs: {level: 2}, getAttrs: parseStyleAttrs}, + {tag: "h3", attrs: {level: 3}, getAttrs: parseStyleAttrs}, + {tag: "h4", attrs: {level: 4}, getAttrs: parseStyleAttrs}, + {tag: "h5", attrs: {level: 5}, getAttrs: parseStyleAttrs}, + {tag: "h6", attrs: {level: 6}, getAttrs: parseStyleAttrs}, + ], + toDOM: node => ["h" + node.attrs.level, {style: serializeStyleAttrs(node.attrs)}, 0] + }, + + + /* + list: { + group: "container", + content: "listItem+", + attrs: { + isOrdered: {default: false}, + isTask: {default: false}, + order: {default: 1}, + tight: {default: false}, + ...styleAttrs + }, + parseDOM: [{tag: "ol, ul", getAttrs: (dom: HTMLElement) => ({ + isOrdered: dom.tagName.toLowerCase() == "ol", + order: dom.hasAttribute("start")? + dom.getAttribute("start")!: 1, + tight: dom.hasAttribute("data-tight"), + ...parseStyleAttrs(dom) + })}] as any, + toDOM: node => [node.attrs.isOrdered? "ol": "ul", { + start: node.attrs.order == 1? null: node.attrs.order, + "data-tight": node.attrs.tight? "true": null, + style: serializeStyleAttrs(node.attrs) + }, 0] + },*/ + + orderedList: { + ...orderedList, + group: "container", + content: "listItem+" + }, + + unorderedList: { + ...bulletList, + group: "container", + content: "listItem+" + }, + + drawer: { + group: "container", + content: "summary paragraph", + attrs: {...styleAttrs}, + parseDOM: [{tag: "details", getAttrs: parseStyleAttrs}], + toDOM: node => ["details", {open: true, style: serializeStyleAttrs(node.attrs)}, 0] + }, + + //@ts-ignore + summary: { + parseDOM: [{tag: "summary"}], + content: "inline*", + toDOM: node => ["summary", 0] + }, + + //@ts-ignore + listItem: { + ...listItem, + content: "inline*", + }, + + ...tableNodes +} + +export const unknownElement: NodeSpec = { + attrs: { + tagName: {}, + otherAttrs: {default: {}} + }, + parseDOM: [{ + tag: "*", + getAttrs: node => { + if(typeof node === "string" || !node.tagName.includes("-")) { + return false + } + else { + const tagName = node.tagName.toLowerCase() + return {tagName, otherAttrs: namedNodeMapToObject(node.attributes)} + } + }, + priority: 0 + }], + toDOM: node => [node.attrs.tagName, node.attrs.otherAttrs] +} \ No newline at end of file diff --git a/@webwriter/core/model/schemas/resourceschema/widgets.ts b/@webwriter/core/model/schemas/resourceschema/widgets.ts new file mode 100644 index 00000000..fa9f495d --- /dev/null +++ b/@webwriter/core/model/schemas/resourceschema/widgets.ts @@ -0,0 +1,104 @@ +import {Node, NodeSpec} from "prosemirror-model" + +import { unscopePackageName } from "../../../utility" +import { Package } from ".." +import { Expression } from "../contentexpression" +import { styleAttrs, parseStyleAttrs, serializeStyleAttrs } from "./nodes" + + + +export function getOtherAttrsFromWidget(dom: HTMLElement) { + return Object.fromEntries(dom + .getAttributeNames() + .filter(name => !["editable", "printable", "analyzable", "contenteditable"].includes(name)) + .map(name => [name, dom.getAttribute(name)])) +} + + +export function slotContentNodeSpecName(packageName: string, slotName: string) { + return `${unscopePackageName(packageName).replace("-", "I")}_SLOT_${slotName}` +} + +export function widgetSlotContent(pkg: Package) { + return Object.keys(pkg.editingConfig?.content ?? {}) + .map(name => slotContentNodeSpecName(pkg.name, name)) + .join(" ") +} + +export function slotContentNodeSpec(pkg: Package, name: string, content: string): NodeSpec { + const nodeName = slotContentNodeSpecName(pkg.name, name) + return { + group: "_slotContent", + content, + toDOM: () => ["div", {class: nodeName + " slot-content", slot: name}, 0], + parseDOM: [{tag: `div.${nodeName}`}] + } +} + +export function getMediaTypesOfContent(content: Record | undefined) { + if(content && content[""]) { + const expr = typeof content[""] === "string"? content[""]: content[""].raw + const matches = [...expr.matchAll(/#\w+(?:\/[-+.\w]+)?/g)] + return matches.map(match => match[0].slice(1)) + } + else { + return [] + } +} + +export function packageWidgetNodeSpec(pkg: Package): NodeSpec { + const maybeContent = pkg.editingConfig?.content + ? {content: widgetSlotContent(pkg)} + : undefined + const mediaTypes = getMediaTypesOfContent(pkg.editingConfig?.content) + const mediaNodeNames = mediaTypes + .map(t => t.slice(1).replaceAll("/", "__").replaceAll("-", "_")) + const maybeMediaParseRules = mediaTypes.length > 0? [ + + ]: [] + + return { + group: "leaf", + widget: true, + package: pkg, + selectable: true, + draggable: false, + isolating: false, + ...maybeContent, + handledMediaNodes: () => mediaNodeNames, + supportsMediaType: (mediaType: string) => mediaTypes.includes(mediaType), + attrs: { + id: {}, + editable: {default: false}, + printable: {default: false}, + analyzable: {default: false}, + otherAttrs: {default: {}}, + ...styleAttrs + }, + parseDOM : [{tag: unscopePackageName(pkg.name), getAttrs: (dom: HTMLElement ) => { + console.log(parseStyleAttrs(dom)) + return { + id: dom.getAttribute("id"), + editable: dom.getAttribute("editable") ?? false, + printable: dom.getAttribute("printable") ?? false, + analyzable: dom.getAttribute("analyzable") ?? false, + otherAttrs: Object.fromEntries(dom + .getAttributeNames() + .filter(name => !["editable", "printable", "analyzable"].includes(name)) + .map(name => [name, dom.getAttribute(name)])), + ...parseStyleAttrs(dom) + } + }}, ...maybeMediaParseRules] as any, + toDOM: (node: Node) => { + return [node.type.name, { + id: node.attrs.id, + ...(node.attrs.editable? {"editable": true}: {}), + ...(node.attrs.printable? {"printable": true}: {}), + ...(node.attrs.analyzable? {"analyzable": true}: {}), + ...node.attrs.otherAttrs, + "class": "ww-widget", + style: serializeStyleAttrs(node.attrs) + }].concat(pkg.editingConfig?.content? [0]: []) as any + } + } +} diff --git a/@webwriter/core/model/stores/documentstore.ts b/@webwriter/core/model/stores/documentstore.ts new file mode 100644 index 00000000..024568a9 --- /dev/null +++ b/@webwriter/core/model/stores/documentstore.ts @@ -0,0 +1,125 @@ +import { EditorState } from "prosemirror-state" +import { Schema } from "prosemirror-model" + +import { createEditorState, Environment } from ".." +import { getFileExtension } from "../../utility" +import * as marshal from "../marshal" +import * as connect from "../connect" +import { redoDepth, undoDepth } from "prosemirror-history" + +const BINARY_EXTENSIONS = Object.entries(marshal).flatMap(([k, v]) => v.isBinary? v.extensions: []) +const ALL_FILTER = {name: "Explorable", extensions: Object.values(marshal).flatMap(v => v.extensions)} +const INDIVIDUAL_FILTERS = Object.entries(marshal).map(([k, v]) => ({name: v.label, extensions: v.extensions})) +const FILTERS = [ALL_FILTER, ...INDIVIDUAL_FILTERS] + +type Resource = { + url: string + editorState: EditorState +} + +type Options = { + bundle: Environment["bundle"], + schema?: Schema +} + +/** Manages all resources. A resource is the app's internal document format. Resources have `editorState`, storing all the document's data in the ProseMirror format. They are referred to with URLs, indicating whether the resources are in memory (not saved yet) or external such as on the user's hard drive (saved before at `url`). */ +export class DocumentStore implements Resource { + + url: string + editorState: EditorState + isPreviewing: boolean = false + schema: Schema + lastSavedState: EditorState + + bundle: Options["bundle"] + + constructor(options: Options) { + Object.assign(this, options) + this.create() + } + + get changed() { + return !this.lastSavedState.doc.eq(this.editorState.doc) + } + + /** Updates the document schema with the store's schema. */ + updateSchema() { + this.editorState = createEditorState({...this.editorState, schema: this.schema}) + } + + /** Gets a new, unused resource URL. */ + getNewURL() { + return `memory:0` + /* + const memoryNumberIDs = Object.keys(this._resources) + .map(url => new URL(url)) + .filter(url => url.protocol="memory") + .map(url => parseInt(url.pathname)) + .filter(num => !Number.isNaN(num)) + return `memory:${Math.max(-1, ...memoryNumberIDs) + 1}` + */ + } + + /** Creates a new resource. */ + create(url: Resource["url"] = this.getNewURL(), schema: Schema = this.schema) { + this.editorState = this.lastSavedState = createEditorState({schema}) + this.url = url + } + + get undoDepth() { + return undoDepth(this.editorState) + } + + get redoDepth() { + return redoDepth(this.editorState) + } + + /** Saves a resource on an external file system. */ + async save(saveAs=false) { + const resource = this + let urlObj = new URL(resource?.url ?? "memory:/") + if(urlObj.protocol === "memory:" || saveAs) { + const path = await connect["file"].pickSave(INDIVIDUAL_FILTERS) + if(path === null) { + return + } + urlObj = new URL("file:/") + urlObj.pathname = path + } + + const protocol = urlObj.protocol.slice(0, -1) + const format = getFileExtension(urlObj.href) + const save = (connect as any)[protocol].save + const serialize = (marshal as any)[format].serialize + const isBinary = (marshal as any)[format].isBinary + + let data = await serialize(resource.editorState.doc, this.bundle) + await save(data, urlObj.href, isBinary) + this.lastSavedState = this.editorState + } + + /** Loads a resource from an external file system. */ + async load(url?: Resource["url"]) { + let urlObj = new URL("memory:/") + if(!url) { + urlObj.protocol = "file:" + const path = await connect["file"].pickLoad(INDIVIDUAL_FILTERS) + if(path === null) {return} + urlObj.pathname = path as string + } + else { + urlObj = new URL(url) + } + + const protocol = urlObj.protocol.slice(0, -1) + const format = getFileExtension(urlObj.href) + const load = (connect as any)[protocol].load + const parse = (marshal as any)[format].parse + + let data = await load(urlObj.href, BINARY_EXTENSIONS) + let editorState = await parse(data, this.schema) + this.url = urlObj.href + this.editorState = this.lastSavedState = editorState + } + +} \ No newline at end of file diff --git a/@webwriter/core/model/stores/index.ts b/@webwriter/core/model/stores/index.ts index 9c51b773..4bc5d019 100644 --- a/@webwriter/core/model/stores/index.ts +++ b/@webwriter/core/model/stores/index.ts @@ -5,10 +5,13 @@ export * from "./uistore" import { ZodSchema } from "zod" import merge from "lodash.merge" -import { createSchema, Package, PackageStore, ResourceStore, UIStore } from ".." +import { createSchema, Package, PackageStore, UIStore } from ".." import { Environment } from "../environment" +import { ResourceStore } from "./resourcestore" -type AllOptions = ConstructorParameters[0] & ConstructorParameters[0] +type StoreOptions any> = ConstructorParameters[0] + +type AllOptions = StoreOptions & StoreOptions type OmitFunctions = Pick @@ -30,12 +33,14 @@ export class RootStore { FS: Environment["FS"] Path: Environment["Path"] + Dialog: Environment["Dialog"] - constructor({corePackages, schema, FS, Path, Shell, HTTP, OS, Dialog, bundle, search, pm, watch, getSystemFonts}: AllOptions) { + constructor({corePackages, schema, FS, Path, Shell, HTTP, OS, Dialog, bundle, search, pm, watch, getSystemFonts, createWindow}: AllOptions) { const onImport = this.onImportPackages this.FS = FS this.Path = Path - this.packages = new PackageStore({corePackages, FS, Path, Shell, HTTP, OS, Dialog, bundle, search, pm, watch, onImport, getSystemFonts}) + this.Dialog = Dialog + this.packages = new PackageStore({corePackages, FS, Path, Shell, HTTP, OS, Dialog, bundle, search, pm, watch, onImport, getSystemFonts, createWindow}) this.resources = new ResourceStore({schema, bundle}) this.ui = new UIStore() } @@ -63,7 +68,7 @@ export class RootStore { const defaults = schema.parse(this) const settings = schema.parse(merge(defaults, JSON.parse(contents))) Object.entries(settings) - .flatMap(([sk, sv]) => Object.entries(sv).map(([k, v]) => [sk, k, v])) + .flatMap(([sk, sv]) => Object.entries(sv).map(([k, v]) => [sk, k, v])) // @ts-ignore .forEach(([sk, k, v]) => this.set(sk, k, v)) } catch(cause: any) { diff --git a/@webwriter/core/model/stores/packagestore.ts b/@webwriter/core/model/stores/packagestore.ts index f103a9b6..f9f9c017 100644 --- a/@webwriter/core/model/stores/packagestore.ts +++ b/@webwriter/core/model/stores/packagestore.ts @@ -4,6 +4,7 @@ import { Package } from ".." import {version as appVersion} from "../../package.json" import { toJS } from "mobx" +import { licenses, presets } from "../templates" type ProcessingEntry = { key: string @@ -62,33 +63,29 @@ type Options = { onImport?: (packages: Package[]) => void } & Environment -type PackageOptions = {installed?: boolean, outdated?: boolean, root?: string, imported?: boolean, localPath?: string, reloadCount?: number, importError?: string, watching?: boolean, jsSize?: number, cssSize?: number} - -export type PackageWithOptions = Package & PackageOptions - /** Handles packages. Packages are node (npm) packages which contain widgets. The PackageStore can also create bundles from packages, which can for example be imported by the runtime editor or embedded by serializers. Additionally, the PackageStore can open or clear the app directory which stores the packages. */ export class PackageStore { /** Converts a H5P library object (library.json) into a node package (package.json), including the raw library data under the key "h5pLibrary". */ static H5PtoPackageJson(name: string, library: Record): Package { - return { + return new Package({ name, version: `${library["majorVersion"]}.${library["minorVersion"]}.${library["patchVersion"]}`, description: library["description"], license: library["license"], author: library["author"], - keywords: ["webwriter-h5p", "webwriter-widget"], // @ts-ignore: Fix schema + keywords: ["webwriter-h5p", "webwriter-widget"], h5pLibrary: {...library} - } + }) } /** Create a hash value to identify a bundle. The hash is deterministically computed from the packages' names and versions. This allows for caching of existing bundles. */ - static computeBundleHash(packages: PackageWithOptions[], editMode: boolean = false) { + static computeBundleHash(packages: Package[], editMode: boolean = false) { const bundleID = this.computeBundleID(packages, editMode) return hashCode(bundleID).toString(36) } - static computeBundleID(packages: PackageWithOptions[], editMode: boolean = false) { + static computeBundleID(packages: Package[], editMode: boolean = false) { const packageVersions = packages.map(pkg => `${pkg.name}@${pkg.version}-${pkg.reloadCount}`) return packageVersions.join("~") + (editMode? "!edit": "") } @@ -110,7 +107,7 @@ export class PackageStore { _watching: Record = {} _imported: Record = {} - _packages: Record = {} + _packages: Record = {} corePackages: Package["name"][] = [] bundleCode: string = "" bundleCSS: string = "" @@ -159,19 +156,17 @@ export class PackageStore { private _reloadCounts: Record = {} - private _cachedPackages: PackageWithOptions[] = [] + private _cachedPackages: Package[] = [] - get packages(): PackageWithOptions[] { + get packages(): Package[] { const cached = this._cachedPackages - const pkgs = Object.values(this._packages).map(pkg => ({ - ...pkg, + const pkgs = Object.values(this._packages).map(pkg => pkg.extend({ importError: this.importError[pkg.name], watching: Boolean(this.watching[pkg.name]) })) - const isPkgsInCached = pkgs.every(pkg => cached.find(cpkg => JSON.stringify(cpkg) === JSON.stringify(pkg))) const isCachedInPkgs = cached.every(cpkg => cached.find(pkg => JSON.stringify(cpkg) === JSON.stringify(pkg))) - if(isPkgsInCached && isCachedInPkgs) { + if(false && isPkgsInCached && isCachedInPkgs) { // TODO return this._cachedPackages } else { @@ -180,11 +175,11 @@ export class PackageStore { } } - set packages(value: PackageWithOptions[] | Record) { + set packages(value: Package[] | Record) { const pkgs = Array.isArray(value) ? Object.fromEntries(value.map(x => [x.name, x])) : value - this._packages = pkgs + this._packages = pkgs as any } @@ -204,7 +199,8 @@ export class PackageStore { this.cleanupWatching(toCleanup) const toAddPaths = toAdd.map(k => this._packages[k].localPath as string) Promise.all(toAddPaths.map(k => this.watch(k, e => this.handleLocalPathChange(k, e), {recursive: true})) - ).then(cbs => this.setWatchingCallbacks(toAdd, cbs)) + ).then(cbs => this.setWatchingCallbacks(toAdd, cbs)) + setTimeout(() => console.log(toJS(this._watching))) } private setWatchingCallbacks(names: string[], callbacks: (() => void)[]) { @@ -251,8 +247,8 @@ export class PackageStore { const packageJsonPath = await this.Path.join(appDir, "package.json") const packageJsonExists = await this.FS.exists(packageJsonPath) if(!packageJsonExists) { - const pkgConfig: Package = {name: "webwriter.webwriter", version: appVersion, license: "UNLICENSED"} - await this.FS.writeFile(packageJsonPath, JSON.stringify(pkgConfig)) + const pkgConfig = new Package({name: "webwriter.webwriter", version: appVersion, license: "UNLICENSED"}) + await this.FS.writeFile(packageJsonPath, pkgConfig.serialize() as string) await this.pm("add", this.corePackages, true, appDir) // await Promise.all(H5P_REPOSITORIES.map(this.installH5Package)) } @@ -261,13 +257,13 @@ export class PackageStore { await this.import(importable ?? [], {editMode: true}) } - async testImportable(packages: PackageWithOptions[], setImportError=true) { + async testImportable(packages: Package[], setImportError=true) { const pkgs = Object.fromEntries(packages.map(pkg => [pkg.name, pkg])) for(const pkg of this.packages) { try { const options = {bundlename: `test-importable`, force: false, editMode: true} const {jsSize, cssSize} = await this.writeBundle([pkg], options) ?? {} - const updatedPkg = {...pkg, jsSize, cssSize} + const updatedPkg = pkg.extend({jsSize, cssSize}) pkgs[pkg.name] = updatedPkg } catch(error: any) { @@ -285,7 +281,7 @@ export class PackageStore { onDone() {(this as any).fetching = false} }) async fetchInstalled(setPackages=true, incrementReloadCount: string | null = null) { - let packages = [] as PackageWithOptions[] + let packages = [] as Package[] const appDir = await this.Path.appDir() const packageJsonPath = await this.Path.join(appDir, "package.json") const packageJsonString = await this.FS.readFile(packageJsonPath) as string @@ -294,6 +290,7 @@ export class PackageStore { const pkgs = await Promise.all(pkgJsonPaths.map(async p => JSON.parse(await this.FS.readFile(p) as string))) if(pkgs) { packages = Object.values(pkgs) + .map(pkg => new Package(pkg)) .filter(pkg => pkg.keywords?.includes("webwriter-widget")) .map(pkg => { const identifier = dependencies[pkg.name] @@ -302,10 +299,10 @@ export class PackageStore { if(incrementReloadCount === pkg.name) { this._reloadCounts = {...this._reloadCounts, [pkg!.name]: (this._reloadCounts[pkg!.name] ?? 0) + 1} } - return {...pkg, installed: true, imported, localPath, reloadCount: this._reloadCounts[pkg.name] ?? 0} + return pkg.extend({installed: true, imported, localPath, reloadCount: this._reloadCounts[pkg.name] ?? 0}) }) const importErrors = await this.testImportable(packages) - packages = packages.map(pkg => ({...pkg, importError: importErrors[pkg.name]})) + packages = packages.map(pkg => pkg.extend({importError: importErrors[pkg.name]})) } if(setPackages) { this.importError = {} @@ -321,7 +318,7 @@ export class PackageStore { }) async fetchAvailable(from?: number) { const {total, objects} = await this.search("keywords:webwriter-widget", {from}) - const packages = objects.map(obj => obj["package"]) + const packages = objects.map(obj => obj["package"]).map(pkg => new Package(pkg)) return packages } @@ -337,11 +334,11 @@ export class PackageStore { const outdated = installed .filter(({name, version}) => { const availVersion = available.find(pkg => pkg.name === name)?.version - return availVersion && availVersion !== version + return availVersion && String(availVersion) !== String(version) }) this.packages = [ ...available.filter(pkg => !installedPkgNames.includes(pkg.name)), - ...installed.map(pkg => ({...pkg, outdated: outdated.includes(pkg)})) + ...installed.map(pkg => pkg.extend({outdated: outdated.includes(pkg)})) ] return this.packages } @@ -399,18 +396,17 @@ export class PackageStore { this.watching = Object.fromEntries(pkgs.map(pkg => [pkg, false])) await this.pm("remove", args, true, appDir) await this.fetchAll(0) - console.log(this.installed.map(pkg => pkg.name)) await this.import(this.installed ?? [], {editMode: true}) } /** Writes a bundle to the provided file system. */ - async writeBundle(packages: PackageWithOptions[], {bundlename="bundle", force=false, editMode=false}: {bundlename?: string, force?: boolean, editMode?: boolean} = {bundlename: "bundle", force: false, editMode: false}) { + async writeBundle(packages: Package[], {bundlename="bundle", force=false, editMode=false}: {bundlename?: string, force?: boolean, editMode?: boolean} = {bundlename: "bundle", force: false, editMode: false}) { if(force || !await this.bundleExists(packages, {bundlename, editMode})) { let pkgs = packages const appDir = await this.Path.appDir() if(packages.length > 1) { const importErrors = await this.testImportable(packages) - pkgs = pkgs.map(pkg => ({...pkg, importError: importErrors[pkg.name]})) + pkgs = pkgs.map(pkg => pkg.extend({importError: importErrors[pkg.name]})) } const bundleFilename = `${bundlename}#${PackageStore.computeBundleHash(pkgs, editMode)}` const bundlePath = await this.Path.join(appDir, bundleFilename) @@ -424,7 +420,7 @@ export class PackageStore { }) const entrypoint = exportStatements.join(";") this.FS.writeFile(entrypointPath, entrypoint) - await this.bundle([`${entrypointPath}`, "--bundle", "--sourcemap=inline", `--outfile=${bundlePath}.js`, `--format=esm`]) + await this.bundle([`${entrypointPath}`, "--bundle", "--sourcemap=inline", `--outfile=${bundlePath}.js`, `--format=esm`, ]) const jsSize = (await this.FS.stat(bundlePath + ".js"))?.size const cssSize = (await this.FS.stat(bundlePath + ".css"))?.size return {bundlePath, packages: pkgs, jsSize, cssSize} @@ -432,7 +428,7 @@ export class PackageStore { } /** Loads bundle code from the provided file system into the store, to be imported by the view later. */ - async import(packages: PackageWithOptions[], {bundlename="bundle", editMode=false}: {bundlename?: string, editMode?: boolean} = {bundlename: "bundle", editMode: false}) { + async import(packages: Package[], {bundlename="bundle", editMode=false}: {bundlename?: string, editMode?: boolean} = {bundlename: "bundle", editMode: false}) { const packageNames = packages.map(pkg => pkg.name) const appDir = await this.Path.appDir() const bundleFilename = `${bundlename}#${PackageStore.computeBundleHash(packages, editMode)}` @@ -443,13 +439,13 @@ export class PackageStore { this.bundleCode = bundleCode as string this.bundleCSS = bundleCSS as string const importedPackages = packages.map(pkg => pkg.name) - this.packages = this.packages.map(pkg => importedPackages.includes(pkg.name)? {...pkg, imported: true}: pkg) + this.packages = this.packages.map(pkg => importedPackages.includes(pkg.name)? pkg.extend({imported: true}): pkg) this.bundleID = PackageStore.computeBundleID(this.imported, editMode) this.onImport? this.onImport(packages): null } /** Checks if the bundle already exists on disk. */ - async bundleExists(packages: PackageWithOptions[], {bundlename="bundle", editMode=false}: {bundlename?: string, editMode?: boolean} = {bundlename: "bundle", editMode: false}) { + async bundleExists(packages: Package[], {bundlename="bundle", editMode=false}: {bundlename?: string, editMode?: boolean} = {bundlename: "bundle", editMode: false}) { const hash = PackageStore.computeBundleHash(packages, editMode) const bundleFilename = `${bundlename}#${hash}` const appDir = await this.Path.appDir() @@ -469,34 +465,62 @@ export class PackageStore { onDone() {(this as any).resetting = false} }) async resetAppDir() { + this.initializing = true const appDir = await this.Path.appDir() await this.FS.rmdir(appDir) return this.initialize() } - /** Adds a local directory as a package. If it does not contain a package, create a package there. */ + /** Adds a directory as a local package. */ + @storeAction({}) + async addLocal(path: string) { + const resolvedPath = await this.Path.resolve(path) + await this.add([`link:${resolvedPath}`]) + } + + /** Reads a local package directory, returning the package config. */ @storeAction({}) - async addLocal(path?: string, pkg?: Package) { - const localPath = path ?? await this.Dialog.promptRead({directory: true, multiple: false, recursive: true}) as string | null - if(localPath === null) { - return + async readLocal(path: string) { + const resolvedPath = await this.Path.resolve(path) + const pkgJsonPath = await this.Path.join(resolvedPath, "package.json") + const exists = await this.FS.exists(pkgJsonPath) + if(!exists) { + throw Error("No package found under " + pkgJsonPath) } - const appDir = await this.Path.appDir() - const resolvedPath = await this.Path.resolve(localPath) - const basename = await this.Path.basename(resolvedPath) + const pkgString = await this.FS.readFile(pkgJsonPath) as string + const pkg = Package.parse(JSON.parse(pkgString)) + return pkg + } + + /** Write a given package to a directory, creating files as neccessary. If `force` is false, abort if existing files are found. */ + @storeAction({}) + async writeLocal(path: string, pkg: Package, {extraFiles = {} as Record, mergePackage=false, overwrite=false, preset="none", generateLicense=false}) { + const resolvedPath = await this.Path.resolve(path) + + let allExtraFiles = {...extraFiles} + if(preset && preset in presets) { + allExtraFiles = {...allExtraFiles, ...(presets as any)[String(preset)](pkg)} + } + if(generateLicense && String(pkg.license) in licenses) { + allExtraFiles = {...allExtraFiles, ...(licenses as any)[String(pkg.license)](pkg)} + } + await Promise.all(Object.keys(allExtraFiles).map(async fileName => { + const extraPath = await this.Path.join(resolvedPath, fileName) + const extraExists = await this.FS.exists(extraPath) + if(extraExists && !overwrite) { + throw Error("Existing extra file found under " + extraPath) + } + return this.FS.writeFile(extraPath, allExtraFiles[fileName]) + })) + const pkgJsonPath = await this.Path.join(resolvedPath, "package.json") - const existingPkg = await this.FS.exists(pkgJsonPath) - ? Package.parse(JSON.parse(await this.FS.readFile(pkgJsonPath) as string)) - : null - const resolvedPkg: Package = existingPkg - ?? pkg - ?? {name: basename, version: "0.0.1", keywords: ["webwriter-widget"]} - if(!existingPkg) { - this.FS.writeFile(pkgJsonPath, Package.serialize(resolvedPkg)) + const exists = await this.FS.exists(pkgJsonPath) + if(exists && !mergePackage) { + throw Error("Existing package.json file found under " + pkgJsonPath) } - const url = new URL("link:") - url.pathname = resolvedPath - await this.add([`link:${resolvedPath}`]) + const existingPkg = exists? new Package(JSON.parse(await this.FS.readFile(pkgJsonPath) as string)): null + const newPkg = existingPkg? existingPkg.extend(pkg): pkg + await this.FS.writeFile(pkgJsonPath, String(newPkg)) } @storeAction({queueKey: "pending"}) @@ -504,4 +528,21 @@ export class PackageStore { this.watching = {...this.watching, [name]: !this.watching[name]} } + /** Open the main file specified in the given package's config. */ + @storeAction({}) + async openMain(name: Package["name"]) { + if(!(name in this._packages)) { + throw Error(`Package ${name} not found`) + } + const pkg = this._packages[name] + if(pkg.main) { + const appDir = await this.Path.appDir() + const path = await this.Path.join(appDir, "node_modules", name, pkg.main) + return this.Shell.open(path) + } + else { + throw Error(`No main file configured for package ${name}`) + } + } + } \ No newline at end of file diff --git a/@webwriter/core/model/stores/resourcestore.ts b/@webwriter/core/model/stores/resourcestore.ts index 0ba57000..7e61ef58 100644 --- a/@webwriter/core/model/stores/resourcestore.ts +++ b/@webwriter/core/model/stores/resourcestore.ts @@ -1,11 +1,12 @@ import { EditorState } from "prosemirror-state" -import { Schema } from "prosemirror-model" +import { Schema, Mark, Node, NodeType, Attrs } from "prosemirror-model" import { createEditorState, Environment } from ".." -import { getFileExtension } from "../../utility" +import { getFileExtension, groupBy, range } from "../../utility" import * as marshal from "../marshal" import * as connect from "../connect" import { redoDepth, undoDepth } from "prosemirror-history" +import { EditorView } from "prosemirror-view" const BINARY_EXTENSIONS = Object.entries(marshal).flatMap(([k, v]) => v.isBinary? v.extensions: []) const ALL_FILTER = {name: "Explorable", extensions: Object.values(marshal).flatMap(v => v.extensions)} @@ -226,4 +227,99 @@ export class ResourceStore { this.lastSavedState = {...this.lastSavedState, [resource.url]: resource.editorState} } + get activeMarks() { + const {editorState: s} = this.active! + const stored = s.storedMarks ?? [] + const marks = new Set(stored) + s.doc.nodesBetween(s.selection.from, s.selection.to, (node, pos, parent, index) => { + node.marks.forEach(mark => marks.add(mark)) + }) + return Array.from(marks) + } + + get activeNodes() { + const {editorState: s} = this.active! + const nodes = [] as Node[] + s.doc.nodesBetween(s.selection.from, s.selection.to, node => { + nodes.push(node) + }) + return nodes + } + + get activePos() { + const {editorState: s} = this.active! + const posList = [] as number[] + s.doc.nodesBetween(s.selection.from, s.selection.to, (node, pos) => { + posList.push(pos) + }) + return posList + } + + get activeAttributes() { + return this.activeNodes.flatMap(node => { + return Object.entries(node.attrs).map(([key, value]) => { + return {node, key, value} + }) + }) + } + + get activeAttributesByKey() { + return groupBy(this.activeAttributes, "key") + } + + get activeNodeNames() { + return this.activeNodes.filter(node => node.type.name) + } + + get docAttributes() { + const {editorState: s} = this.active! + return s.doc.attrs + } + + getActiveDocAttributeValue(key: string) { + return this.docAttributes[key] + } + + isMarkActive(markName: string) { + return this.activeMarks.some(mark => mark.type.name === markName) + } + + getActiveAttributeValue(key: string) { + const all = (this.activeAttributesByKey[key] ?? []).map(({value}) => value) + const unique = new Set(all.filter(v => v)) + if(unique.size === 0) { + return undefined + } + else if(unique.size === 1) { + return [...unique][0] + } + else { + return null + } + } + + hasActiveNode(type: string | NodeType, attrs?: Attrs, includeAncestors=false) { + const {editorState: s} = this.active! + let matchFound = false + this.activeNodes.filter(node => { + const typeMatches = typeof type === "string"? node.type.name === type: node.type === type + const attrsMatches = !attrs || Object.keys(attrs).every(k => attrs[k] === node.attrs[k]) + if(typeMatches && attrsMatches) { + matchFound = true + } + }) + if(includeAncestors) { + const resolvedPos = s.selection.$anchor + const ancestors = range(0, resolvedPos.depth).map(i => resolvedPos.node(i)) + } + return matchFound + } + + getActiveComputedStyles(view: EditorView) { + const {getComputedStyle} = view.dom.ownerDocument.defaultView! + return this.activePos + .map(pos => view.nodeDOM(pos) as Element) + .map(element => getComputedStyle(element)) + } + } \ No newline at end of file diff --git a/@webwriter/core/model/stores/uistore.ts b/@webwriter/core/model/stores/uistore.ts index 5970c3e2..be3815de 100644 --- a/@webwriter/core/model/stores/uistore.ts +++ b/@webwriter/core/model/stores/uistore.ts @@ -10,9 +10,9 @@ export class UIStore { notifications: Notification[] = [] - showTextPlaceholder: boolean = true + showTextPlaceholder: boolean = false - showWidgetPreview: boolean = true + showWidgetPreview: boolean = false keymap: Record = {} diff --git a/@webwriter/core/model/templates/index.ts b/@webwriter/core/model/templates/index.ts new file mode 100644 index 00000000..7ba830ae --- /dev/null +++ b/@webwriter/core/model/templates/index.ts @@ -0,0 +1,65 @@ +import { capitalizeWord } from "../../utility" +import { Package } from "../schemas" + +import litIndex from "./presets/lit/index.ts?raw" +import litPackage from "./presets/lit/package.json?raw" +import litTsconfig from "./presets/lit/tsconfig.json?raw" +import MIT from "./licenses/MIT.txt?raw" +import ISC from "./licenses/ISC.txt?raw" +import Apache2 from "./licenses/Apache-2.0.txt?raw" +import BSD2 from "./licenses/BSD-2-Clause.txt?raw" +import BSD3 from "./licenses/BSD-3-Clause.txt?raw" + + +const interpolateTemplate = (template: string, pkg: Package) => { + + let result = template + + const replacementMap: Record = { + "____classname____": pkg.name.split("-").slice(1).map(capitalizeWord).join("") || "MyWidget", + "____year____": String(new Date().getFullYear()) + } + for (const [key, value] of Object.entries(pkg.serialize("object"))) { + replacementMap[`___${key}___`] = String(value) + replacementMap[`---${key}---`] = String(value) + } + for (const [key, value] of Object.entries(replacementMap)) { + result = result.replaceAll(key, value) + } + return result +} + +const interpolateTemplateRecord = (record: Record, pkg: Package) => { + let result = {...record} + for (const [key, template] of Object.entries(record)) { + result[key] = interpolateTemplate(template, pkg) + } + return result +} + + +export const presets = { + lit: (pkg: Package) => interpolateTemplateRecord({ + "index.ts": litIndex, + "package.json": litPackage, + "tsconfig.json": litTsconfig + }, pkg) +} + +export const licenses = { + "MIT": (pkg: Package) => interpolateTemplateRecord({ + "LICENSE": MIT + }, pkg), + "ISC": (pkg: Package) => interpolateTemplateRecord({ + "LICENSE": ISC + }, pkg), + "Apache-2.0": (pkg: Package) => interpolateTemplateRecord({ + "LICENSE": Apache2 + }, pkg), + "BSD-2-Clause": (pkg: Package) => interpolateTemplateRecord({ + "LICENSE": BSD2 + }, pkg), + "BSD-3-Clause": (pkg: Package) => interpolateTemplateRecord({ + "LICENSE": BSD3 + }, pkg), +} \ No newline at end of file diff --git a/@webwriter/core/model/templates/licenses/Apache-2.0.txt b/@webwriter/core/model/templates/licenses/Apache-2.0.txt new file mode 100644 index 00000000..4668ed12 --- /dev/null +++ b/@webwriter/core/model/templates/licenses/Apache-2.0.txt @@ -0,0 +1,13 @@ +Copyright ____year____ ___author___ + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. \ No newline at end of file diff --git a/@webwriter/core/model/templates/licenses/BSD-2-Clause.txt b/@webwriter/core/model/templates/licenses/BSD-2-Clause.txt new file mode 100644 index 00000000..a541f22b --- /dev/null +++ b/@webwriter/core/model/templates/licenses/BSD-2-Clause.txt @@ -0,0 +1,9 @@ +Copyright ____year____ ___author___ + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/@webwriter/core/model/templates/licenses/BSD-3-Clause.txt b/@webwriter/core/model/templates/licenses/BSD-3-Clause.txt new file mode 100644 index 00000000..da38df2d --- /dev/null +++ b/@webwriter/core/model/templates/licenses/BSD-3-Clause.txt @@ -0,0 +1,11 @@ +Copyright ____year____ ___author___ + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/@webwriter/core/model/templates/licenses/ISC.txt b/@webwriter/core/model/templates/licenses/ISC.txt new file mode 100644 index 00000000..b243038a --- /dev/null +++ b/@webwriter/core/model/templates/licenses/ISC.txt @@ -0,0 +1,5 @@ +Copyright ____year____ ___author___ + +Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. \ No newline at end of file diff --git a/@webwriter/core/model/templates/licenses/MIT.txt b/@webwriter/core/model/templates/licenses/MIT.txt new file mode 100644 index 00000000..8391b5b3 --- /dev/null +++ b/@webwriter/core/model/templates/licenses/MIT.txt @@ -0,0 +1,7 @@ +Copyright ____year____ ___author___ + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “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: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +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. \ No newline at end of file diff --git a/@webwriter/core/model/templates/presets/lit/index.ts b/@webwriter/core/model/templates/presets/lit/index.ts new file mode 100644 index 00000000..211102fb --- /dev/null +++ b/@webwriter/core/model/templates/presets/lit/index.ts @@ -0,0 +1,10 @@ +import {html} from "lit" +import {LitElementWw} from "@webwriter/lit" +import {customElement} from "lit/decorators.js" + +@customElement("---name---") +export class ____classname____ extends LitElementWw { + render() { + return html`Hello, world!` + } +} \ No newline at end of file diff --git a/@webwriter/core/model/templates/presets/lit/package.json b/@webwriter/core/model/templates/presets/lit/package.json new file mode 100644 index 00000000..7037f772 --- /dev/null +++ b/@webwriter/core/model/templates/presets/lit/package.json @@ -0,0 +1,9 @@ +{ + "name": "ww-lit-preset", + "version": "0.1.0", + "main": "index.ts", + "dependencies": { + "lit": "*", + "@webwriter/lit": "*" + } +} \ No newline at end of file diff --git a/@webwriter/core/model/templates/presets/lit/tsconfig.json b/@webwriter/core/model/templates/presets/lit/tsconfig.json new file mode 100644 index 00000000..a178f9dc --- /dev/null +++ b/@webwriter/core/model/templates/presets/lit/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "experimentalDecorators": true + } +} \ No newline at end of file diff --git a/@webwriter/core/utility.ts b/@webwriter/core/utility.ts index cdfee23d..b8a3f397 100644 --- a/@webwriter/core/utility.ts +++ b/@webwriter/core/utility.ts @@ -182,7 +182,7 @@ export function sameMembers(a: Iterable | any, b: Iterable | any) { */ export function shallowCompare(obj1: any, obj2: any) { return Object.keys(obj1).length === Object.keys(obj2).length - && Object.keys(obj1).every(key => obj2.hasOwnProperty(key) + && Object.keys(obj1).every(key => Object.hasOwn(obj2, key) && obj1[key] === obj2[key]) } @@ -202,4 +202,146 @@ export function pickObject(value: T, keys: K[]) return Object.fromEntries(keys.map(k => [k, value[k]])) as Pick } -export {default as groupBy} from "lodash.groupby" \ No newline at end of file +/** Return a range of numbers up to `a` or starting at `a` and up to, but excluding `b`. + */ +export function range(a: number, b?: number) { + return [...Array((b ?? a*2) - a).keys()].map(x => x + (b? a: 0)) +} + +export {default as groupBy} from "lodash.groupby" + + +let ELEMENT_RE = /[\w-]+/g, + ID_RE = /#[\w-]+/g, + CLASS_RE = /\.[\w-]+/g, + ATTR_RE = /\[[^\]]+\]/g, + // :not() pseudo-class does not add to specificity, but its content does as if it was outside it + PSEUDO_CLASSES_RE = /\:(?!not)[\w-]+(\(.*\))?/g, + PSEUDO_ELEMENTS_RE = /\:\:?(after|before|first-letter|first-line|selection)/g; +// convert an array-like object to array +function toArray(list: any): any[] { + return [].slice.call(list); +} + +// handles extraction of `cssRules` as an `Array` from a stylesheet or something that behaves the same +function getSheetRules(stylesheet: CSSStyleSheet) { + let sheet_media = stylesheet.media && stylesheet.media.mediaText; + // if this sheet is disabled skip it + if ( stylesheet.disabled ) return []; + // if this sheet's media is specified and doesn't match the viewport then skip it + if ( sheet_media && sheet_media.length && ! window.matchMedia(sheet_media).matches ) return []; + // get the style rules of this sheet + return toArray(stylesheet.cssRules); +} + +function _find(string: string, re: RegExp) { + let matches = string.match(re); + return matches ? matches.length : 0; +} + +// calculates the specificity of a given `selector` +function calculateScore(selector: string) { + let score = [0,0,0], + parts = selector.split(' '), + part, match; + //TODO: clean the ':not' part since the last ELEMENT_RE will pick it up + while (part = parts.shift(), typeof part == 'string') { + // find all pseudo-elements + match = _find(part, PSEUDO_ELEMENTS_RE); + score[2] += match; + // and remove them + match && (part = part.replace(PSEUDO_ELEMENTS_RE, '')); + // find all pseudo-classes + match = _find(part, PSEUDO_CLASSES_RE); + score[1] += match; + // and remove them + match && (part = part.replace(PSEUDO_CLASSES_RE, '')); + // find all attributes + match = _find(part, ATTR_RE); + score[1] += match; + // and remove them + match && (part = part.replace(ATTR_RE, '')); + // find all IDs + match = _find(part, ID_RE); + score[0] += match; + // and remove them + match && (part = part.replace(ID_RE, '')); + // find all classes + match = _find(part, CLASS_RE); + score[1] += match; + // and remove them + match && (part = part.replace(CLASS_RE, '')); + // find all elements + score[2] += _find(part, ELEMENT_RE); + } + return parseInt(score.join(''), 10); +} + +// returns the heights possible specificity score an element can get from a give rule's selectorText +function getSpecificityScore(element: Element, selector_text: string) { + let selectors = selector_text.split(','), + selector, score, result = 0; + while (selector = selectors.shift()) { + if (matchesSelector(element, selector)) { + score = calculateScore(selector); + result = score > result ? score : result; + } + } + return result; +} + +function sortBySpecificity(element: Element, rules: CSSStyleRule[]) { + // comparing function that sorts CSSStyleRules according to specificity of their `selectorText` + return rules.sort((a, b) => getSpecificityScore(element, b.selectorText) - getSpecificityScore(element, a.selectorText)); +} + +// Find correct matchesSelector impl +function matchesSelector(el: any, selector: any) { + var matcher = el.matchesSelector || el.mozMatchesSelector || + el.webkitMatchesSelector || el.oMatchesSelector || el.msMatchesSelector; + return matcher.call(el, selector); +} + +//TODO: not supporting 2nd argument for selecting pseudo elements +//TODO: not supporting 3rd argument for checking author style sheets only +export const getMatchedCSSRules = (element: Element /*, pseudo, author_only*/) => { + let style_sheets: CSSStyleSheet[] = [] + let sheet: CSSStyleSheet | undefined + let rules: any[] = [] + let rule: any | undefined + let result: CSSStyleRule[] = [] + // get stylesheets and convert to a regular Array + style_sheets = toArray(element.ownerDocument.styleSheets); + + // assuming the browser hands us stylesheets in order of appearance + // we iterate them from the beginning to follow proper cascade order + while (sheet = style_sheets.shift()) { + // get the style rules of this sheet + rules = getSheetRules(sheet); + // loop the rules in order of appearance + while (rule = rules.shift()) { + // if this is an @import rule + if (rule.styleSheet) { + // insert the imported stylesheet's rules at the beginning of this stylesheet's rules + rules = getSheetRules(rule.styleSheet).concat(rules); + // and skip this rule + continue; + } + // if there's no stylesheet attribute BUT there IS a media attribute it's a media rule + else if (rule.media) { + // insert the contained rules of this media rule to the beginning of this stylesheet's rules + rules = getSheetRules(rule).concat(rules); + // and skip it + continue + } + + // check if this element matches this rule's selector + if (matchesSelector(element, rule.selectorText)) { + // push the rule to the results set + result.push(rule); + } + } + } + // sort according to specificity + return sortBySpecificity(element, result); +} \ No newline at end of file diff --git a/@webwriter/core/view/configurator/configurator.ts b/@webwriter/core/view/configurator/configurator.ts index 1be091f1..b2e0d80b 100644 --- a/@webwriter/core/view/configurator/configurator.ts +++ b/@webwriter/core/view/configurator/configurator.ts @@ -4,7 +4,7 @@ import { html, css, LitElement } from "lit" import { customElement, property, query } from "lit/decorators.js" import { ZodBoolean, ZodLiteral, ZodSchema, ZodUnion } from "zod" -import { Settings, SettingSpec, KeymapEntry } from "../../viewmodel" +import { Settings, SettingSpec } from "../../viewmodel" @localized() @customElement("ww-configurator") @@ -103,7 +103,7 @@ export class Configurator extends LitElement { const options = schema._def.options as ZodLiteral[] return html` onChange(groupKey, key, (e.target as SlSelect).value)}> ${schema.description} diff --git a/@webwriter/core/view/configurator/index.ts b/@webwriter/core/view/configurator/index.ts index 499b25ba..0ca715b7 100644 --- a/@webwriter/core/view/configurator/index.ts +++ b/@webwriter/core/view/configurator/index.ts @@ -1,3 +1,4 @@ export * from "./configurator" export * from "./packagemanager" -export * from "./keymapmanager" \ No newline at end of file +export * from "./keymapmanager" +export * from "./packageform" \ No newline at end of file diff --git a/@webwriter/core/view/configurator/keymapmanager.ts b/@webwriter/core/view/configurator/keymapmanager.ts index 730e190a..8735b221 100644 --- a/@webwriter/core/view/configurator/keymapmanager.ts +++ b/@webwriter/core/view/configurator/keymapmanager.ts @@ -21,7 +21,7 @@ export class KeymapManager extends LitElement { @property({state: true}) reassigningCommand: string | null = null - @property({state: true}) + @property({type: Array, state: true}) pendingShortcut: string[] = [] static get keyLabels() {return { @@ -48,6 +48,10 @@ export class KeymapManager extends LitElement { "down": msg("↓ Down", {id: "downKey"}), "left": msg("← Left", {id: "leftKey"}), "right": msg("→ Right", {id: "rightKey"}), + "arrowup": msg("↑ Up", {id: "upKey"}), + "arrowdown": msg("↓ Down", {id: "downKey"}), + "arrowleft": msg("← Left", {id: "leftKey"}), + "arrowright": msg("→ Right", {id: "rightKey"}), "home": msg("⤒ Home", {id: "homeKey"}), "end": msg("⤓ End", {id: "endKey"}), "pageup": msg("▲ Pageup", {id: "pageupKey"}), @@ -75,6 +79,12 @@ export class KeymapManager extends LitElement { "f19": msg("F19", {id: "f19Key"}), }} + static get keyLabelsTextOnly() { + return Object.fromEntries(Object.entries(this.keyLabels).map(([k, v]) => { + return [k, v.replaceAll(/[^a-zA-Z0-9 ]/g, "").trim()] + })) + } + static modifiers = ["command", "meta", "shift", "⇧", "control", "ctrl", "option", "alt", "⌥"] static sortKeys(a: string, b: string) { @@ -266,7 +276,7 @@ export class KeymapManager extends LitElement { ${entry.description}
- this.emitShortcutReset(key)}> + this.emitShortcutReset(key)}>