utopia-project 0.37.6 → 0.39.0

data/public/_components/@socketry/syntax/Syntax/Language/super-collider.js

@@ -0,0 +1,70 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('super-collider');
+
+// Keywords
+language.push(['const', 'arg', 'classvar', 'var'], {type: 'keyword'});
+
+// Operators
+language.push(
+	['`', '+', '@', ':', '*', '/', '-', '&', '|', '~', '!', '%', '<', '=', '>'],
+	{
+		type: 'operator'
+	}
+);
+
+// Constants/values
+language.push(
+	[
+		'thisFunctionDef',
+		'thisFunction',
+		'thisMethod',
+		'thisProcess',
+		'thisThread',
+		'this',
+		'super',
+		'true',
+		'false',
+		'nil',
+		'inf'
+	],
+	{type: 'constant'}
+);
+
+// CamelCase class/type names
+language.push(Rule.camelCaseType);
+
+// Single Characters like $a or $\n
+language.push({pattern: /\$(\\)?.\b/, type: 'constant'});
+
+// Symbols: \symbol and 'quotedSymbol'
+language.push({pattern: /\\[a-z_][a-z0-9_]*/i, type: 'symbol'});
+language.push({pattern: /'[^']+'/, type: 'symbol'});
+
+// Comments and links
+language.push(Rule.cStyleComment);
+language.push(Rule.cppStyleComment);
+language.push(Rule.webLink);
+
+// Strings: SuperCollider uses double quotes for Strings
+// Single quotes denote Symbols and are handled above.
+language.push(Rule.doubleQuotedString);
+language.push(Rule.stringEscape);
+
+// Numbers
+language.push(Rule.decimalNumber);
+language.push(Rule.hexNumber);
+
+// Method calls .method and c-style function pattern (identifier()
+language.push({
+	pattern: /(?:\.)([a-z_][a-z0-9_]*)/i,
+	matches: Rule.extractMatches({type: 'function'})
+});
+language.push(Rule.cStyleFunction);
+
+export default function register(syntax) {
+	syntax.register('super-collider', language);
+	// Alias: sc
+	syntax.alias('super-collider', ['sc']);
+}

data/public/_components/@socketry/syntax/Syntax/Language/swift.js

@@ -0,0 +1,176 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('swift');
+
+const keywords = [
+	'associatedtype',
+	'class',
+	'deinit',
+	'enum',
+	'extension',
+	'fileprivate',
+	'func',
+	'import',
+	'init',
+	'inout',
+	'internal',
+	'let',
+	'operator',
+	'private',
+	'protocol',
+	'static',
+	'struct',
+	'subscript',
+	'typealias',
+	'var',
+	'break',
+	'case',
+	'continue',
+	'default',
+	'defer',
+	'do',
+	'else',
+	'fallthrough',
+	'for',
+	'guard',
+	'if',
+	'in',
+	'repeat',
+	'return',
+	'switch',
+	'where',
+	'while',
+	'as',
+	'catch',
+	'is',
+	'rethrows',
+	'throw',
+	'throws',
+	'try',
+	'_',
+	'#available',
+	'#colorLiteral',
+	'#column',
+	'#else',
+	'#elseif',
+	'#endif',
+	'#file',
+	'#fileLiteral',
+	'#function',
+	'#if',
+	'#imageLiteral',
+	'#line',
+	'#selector',
+	'#sourceLocation',
+	'associativity',
+	'convenience',
+	'dynamic',
+	'didSet',
+	'final',
+	'get',
+	'infix',
+	'indirect',
+	'lazy',
+	'left',
+	'mutating',
+	'none',
+	'nonmutating',
+	'optional',
+	'override',
+	'postfix',
+	'precedence',
+	'prefix',
+	'Protocol',
+	'required',
+	'right',
+	'set',
+	'Type',
+	'unowned',
+	'weak',
+	'willSet'
+];
+
+// Operators - ordered longest to shortest
+const operators = [
+	'...',
+	'..<',
+	'->',
+	'+',
+	'*',
+	'/',
+	'-',
+	'&',
+	'|',
+	'~',
+	'!',
+	'%',
+	'<',
+	'=',
+	'>',
+	'(',
+	')',
+	'{',
+	'}',
+	'[',
+	']',
+	'.',
+	',',
+	':',
+	';',
+	'@',
+	'#',
+	'`',
+	'?'
+];
+
+const values = ['self', 'super', 'true', 'false', 'nil'];
+const access = ['fileprivate', 'open', 'private', 'public'];
+
+// Access modifiers
+language.push(access, {type: 'access'});
+
+// Built-in values
+language.push(values, {type: 'constant'});
+
+// Backtick identifiers
+language.push({
+	pattern: /`[^`]+`/g,
+	type: 'identifier'
+});
+
+// String interpolation \(...) - needs special handling
+language.push({
+	pattern: /\\\(([^)]*)\)/g,
+	klass: 'string'
+});
+
+// Types (CamelCase)
+language.push(Rule.camelCaseType);
+
+// Keywords
+language.push(keywords, {type: 'keyword'});
+
+// Operators
+language.push(operators, {type: 'operator'});
+
+// Comments
+language.push(Rule.cStyleComment);
+language.push(Rule.cppStyleComment);
+language.push(Rule.webLink);
+
+// Strings
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+language.push(Rule.stringEscape);
+
+// Numbers
+language.push(Rule.decimalNumber);
+language.push(Rule.hexNumber);
+
+// Functions
+language.push(Rule.cStyleFunction);
+
+export default function register(syntax) {
+	syntax.register('swift', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/xml.js

@@ -0,0 +1,76 @@
+/**
+ * XML language syntax highlighting
+ * Supports XML tags, attributes, entities, CDATA sections, and comments
+ */
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+// XML entity pattern: &entity;
+const xmlEntity = {pattern: /&\w+;/, type: 'entity'};
+
+// XML percent escape pattern for URL encoding
+const xmlPercentEscape = {
+	pattern: /(%[0-9a-f]{2})/i,
+	type: 'percent-escape',
+	only: ['string']
+};
+
+// Create xml-tag language for highlighting XML tag internals
+const xmlTagLanguage = new Language('xml-tag');
+
+// Match opening/closing tags with optional namespace
+// Pattern: <tag>, <ns:tag>, </tag>, </ns:tag>, <tag/>, etc.
+xmlTagLanguage.push({
+	pattern: /<\/?((?:[^:\s>]+:)?)([^\s>]+)(\s[^>]*)?\/?>/,
+	matches: Rule.extractMatches({type: 'namespace'}, {type: 'tag-name'})
+});
+
+// Match attributes with values
+// Pattern: attribute="value", attribute='value', attribute=value
+xmlTagLanguage.push({
+	pattern: /([^=\s]+)=(".*?"|'.*?'|[^\s>]+)/,
+	matches: Rule.extractMatches(
+		{type: 'attribute', only: ['tag']},
+		{type: 'string', only: ['tag']}
+	)
+});
+
+xmlTagLanguage.push(xmlEntity);
+xmlTagLanguage.push(xmlPercentEscape);
+xmlTagLanguage.push(Rule.singleQuotedString);
+xmlTagLanguage.push(Rule.doubleQuotedString);
+
+// Create main XML language
+
+const language = new Language('xml');
+
+// Match CDATA sections
+// Pattern: <![CDATA[content]]>
+language.push({
+	pattern: /(<!(\[CDATA\[)([\s\S]*?)(\]\])>)/m,
+	matches: Rule.extractMatches(
+		{type: 'cdata', allow: ['cdata-content', 'cdata-tag']},
+		{type: 'cdata-tag'},
+		{type: 'cdata-content'},
+		{type: 'cdata-tag'}
+	)
+});
+
+// XML comments
+language.push(Rule.xmlComment);
+
+// Match all XML tags and delegate to xml-tag language
+language.push({
+	pattern: /<[^>\-\s]([^>'"!\/;\?@\[\]^`\{\}\|]|"[^"]*"|'[^']')*[\/?]?>/,
+	language: 'xml-tag'
+});
+
+language.push(xmlEntity);
+language.push(xmlPercentEscape);
+language.push(Rule.webLink);
+
+// Register both languages
+export default function register(syntax) {
+	syntax.register('xml-tag', xmlTagLanguage);
+	syntax.register('xml', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/xrb.js

@@ -0,0 +1,33 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('xrb');
+
+// Embedded Ruby processing instruction: <?r ... ?>
+language.push({
+	pattern: /(<\?r)([\s\S]*?)(\?>)/m,
+	matches: Rule.extractMatches(
+		{type: 'keyword'},
+		{language: 'ruby'},
+		{type: 'keyword'}
+	)
+});
+
+// Ruby interpolation within text: #{ ... }
+language.push({
+	pattern: /(#{)([\s\S]*?)(})/m,
+	matches: Rule.extractMatches(
+		{type: 'keyword'},
+		{language: 'ruby'},
+		{type: 'keyword'}
+	)
+});
+
+// Derive XML so tags/attributes/entities are highlighted around embedded Ruby
+language.derives('xml');
+
+export default function register(syntax) {
+	syntax.register('xrb', language);
+	// Alias 'trenni' if used historically
+	syntax.alias('xrb', ['trenni']);
+}

data/public/_components/@socketry/syntax/Syntax/Language/yaml.js

@@ -0,0 +1,29 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('yaml');
+
+language.push({
+	pattern: /^\s*#.*$/m,
+	type: 'comment',
+	allow: ['href']
+});
+
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+
+language.push({
+	pattern: /(&|\*)[a-z0-9]+/i,
+	type: 'constant'
+});
+
+language.push({
+	pattern: /(.*?):/i,
+	matches: Rule.extractMatches({type: 'keyword'})
+});
+
+language.push(Rule.webLink);
+
+export default function register(syntax) {
+	syntax.register('yaml', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language.js

@@ -0,0 +1,276 @@
+import {Match} from './Match.js';
+import {Rule} from './Rule.js';
+import {LanguageNotFoundError, RuleApplyError} from './Errors.js';
+
+export class Language {
+	// Public properties that define the language
+	name;
+
+	// A list of processes that may be run after extracting matches.
+	processes = {};
+
+	// A sequential list of rules for extracting matches.
+	#rules = [];
+
+	// A list of all the parent languages this language derives from.
+	#parents = [];
+
+	constructor(name = null) {
+		// The primary class of this language. Must be unique.
+		this.name = name;
+	}
+
+	/**
+	 * Add a parent to the language. This language should be loaded as a dependency.
+	 */
+	derives(name) {
+		this.#parents.push(name);
+		this.#rules.push({
+			apply: async function (syntax, rule, text) {
+				const parentLanguage = await syntax.getLanguage(name);
+				return parentLanguage.getMatches(syntax, text);
+			}
+		});
+	}
+
+	/**
+	 * Return an array of all classes that the language consists of.
+	 */
+	async allNames(syntax) {
+		const names = [this.name];
+
+		for (const parent of this.#parents) {
+			if (syntax) {
+				const parentLanguage = await syntax.getLanguage(parent);
+				if (parentLanguage) names.push(...(await parentLanguage.allNames(syntax)));
+			}
+		}
+
+		return names;
+	}
+
+	/**
+	 * Push a rule onto the language.
+	 */
+	push(...args) {
+		if (Array.isArray(args[0])) {
+			const patterns = args[0];
+			const rule = args[1];
+
+			let all = '(';
+
+			for (let i = 0; i < patterns.length; i += 1) {
+				if (i > 0) all += '|';
+
+				const p = patterns[i];
+
+				if (p instanceof RegExp) {
+					all += p.source;
+				} else {
+					all += Rule.convertStringToTokenPattern(p, true);
+				}
+			}
+
+			all += ')';
+
+			this.push({
+				...rule,
+				pattern: new RegExp(all, rule.options)
+			});
+		} else {
+			const rule = args[0];
+
+			// Normalize and validate the rule
+			const normalized = Rule.normalizeRule(rule, this);
+
+			if (
+				typeof normalized.pattern === 'undefined' ||
+				normalized.pattern instanceof RegExp
+			) {
+				this.#rules.push(normalized);
+			} else {
+				console.error('Syntax Error: Malformed rule: ', rule);
+			}
+		}
+	}
+
+	/**
+	 * Get matches for a specific rule.
+	 */
+	async getMatchesForRule(syntax, text, rule) {
+		let matches = [];
+
+		// Short circuit (user defined) function:
+		if (typeof rule.apply !== 'undefined') {
+			try {
+				const result = rule.apply(syntax, rule, text);
+				matches = result instanceof Promise ? await result : result;
+			} catch (error) {
+				if (syntax?.defaultOptions?.strict) {
+					// If the underlying error is a strict language resolution error, surface it directly:
+					if (error instanceof LanguageNotFoundError) throw error;
+					throw new RuleApplyError(rule, {cause: error});
+				} else {
+					console.warn('Syntax Warning: Rule apply failed:', rule, error);
+					matches = [];
+				}
+			}
+		}
+
+		if (rule.debug) {
+			console.log('Syntax matches:', rule, text, matches);
+		}
+
+		return matches;
+	}
+
+	/**
+	 * Get the rule for a specific type.
+	 */
+	getRuleForType(type) {
+		for (const rule of this.#rules) {
+			if (rule.type === type) {
+				return rule;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get all matches for the given text.
+	 */
+	async getMatches(syntax, text) {
+		const matches = [];
+
+		for (const rule of this.#rules) {
+			matches.push(...(await this.getMatchesForRule(syntax, text, rule)));
+		}
+
+		return matches;
+	}
+
+	/**
+	 * A helper function for building a tree from a specific rule.
+	 */
+	static async buildTree(syntax, rule, text, offset, additionalMatches) {
+		let language;
+		try {
+			language = await syntax.getLanguage(rule.language);
+		} catch (error) {
+			if (syntax?.defaultOptions?.strict) {
+				// Normalize any load error to LanguageNotFoundError for consistency:
+				throw new LanguageNotFoundError(rule.language, {cause: error});
+			} else {
+				console.warn(
+					`Syntax Warning: Failed to load language '${rule.language}' for building tree:`,
+					error
+				);
+				return new Match(offset || 0, text.length, rule, text);
+			}
+		}
+
+		if (!language) {
+			if (syntax?.defaultOptions?.strict) {
+				throw new LanguageNotFoundError(rule.language);
+			} else {
+				console.warn(
+					`Syntax Warning: Language '${rule.language}' not found for building tree.`
+				);
+				// Return a simple match without children as fallback
+				return new Match(offset || 0, text.length, rule, text);
+			}
+		}
+
+		const match = await language.buildTree(
+			syntax,
+			text,
+			offset,
+			additionalMatches
+		);
+
+		Object.assign(match.expression, rule);
+
+		return match;
+	}
+
+	/**
+	 * Build a syntax tree from a given block of text.
+	 */
+	async buildTree(syntax, text, offset, additionalMatches) {
+		offset = offset || 0;
+
+		// Fixes code that uses \r\n for line endings
+		text = text.replace(/\r/g, '');
+
+		const matches = await this.getMatches(syntax, text);
+
+		// Shift matches if offset is provided
+		if (offset && offset > 0) {
+			for (const match of matches) {
+				match.shift(offset);
+			}
+		}
+
+		const top = new Match(
+			offset,
+			text.length,
+			{type: (await this.allNames(syntax)).join(' '), allow: '*', owner: this},
+			text
+		);
+
+		// This sort is absolutely key to the tree insertion algorithm
+		matches.sort(Match.sort);
+
+		for (const match of matches) {
+			top.insertAtEnd(match);
+		}
+
+		if (additionalMatches) {
+			for (const match of additionalMatches) {
+				top.insert(match, true);
+			}
+		}
+
+		top.complete = true;
+
+		return top;
+	}
+
+	/**
+	 * Build a syntax tree and process it into HTML.
+	 */
+	async process(syntax, text, options) {
+		const top = await this.buildTree(syntax, text, 0);
+
+		const lines = top.splitLines();
+
+		const html = document.createElement('code');
+		html.className = 'syntax highlighted';
+		html.setAttribute('part', 'code');
+
+		for (const line of lines) {
+			const processedLine = line.reduce(null, (container, match) => {
+				if (match.expression) {
+					if (match.expression.process) {
+						container = match.expression.process(container, match, options);
+					}
+
+					if (match.expression.owner) {
+						const process = match.expression.owner.processes[match.expression.type];
+						if (process) {
+							container = process(container, match, options);
+						}
+					}
+				}
+				return container;
+			});
+
+			html.appendChild(processedLine);
+		}
+
+		return html;
+	}
+}
+
+export default Language;