@zolomedia/bifrost-client 1.7.74

package/syntax/prism-zolo-theme.css

@@ -0,0 +1,288 @@
+/**
+ * Prism.js CSS Theme for .zolo syntax highlighting
+ * 
+ * AUTO-GENERATED by zlsp/themes/generators/prism.py
+ * DO NOT EDIT MANUALLY - Changes will be overwritten!
+ * 
+ * Generated: 2026-06-08 19:00:23
+ * Source: zlsp/themes/zolo_default.yaml (SSOT)
+ * Maintainer: Run from zlsp to regenerate
+ * 
+ * Colors are derived from the canonical zlsp theme to ensure
+ * consistency between IDE and web syntax highlighting.
+ */
+
+/* zMeta root key in zUI/zSchema files (Zolo convention) */
+.language-zolo .token.special-key,
+.language-zspark .token.special-key {
+  color: #87d787 !important;
+}
+
+/* zMeta root key in zUI/zSchema files (Zolo convention) */
+.language-zolo .token.builtin,
+.language-zspark .token.builtin {
+  color: #87d787 !important;
+}
+
+/* Top-level keys in non-zOS files (app_name, server, features) */
+.language-zolo .token.root-key,
+.language-zspark .token.root-key {
+  color: #87d700 !important;
+  font-weight: 600;
+}
+
+/* Top-level keys in non-zOS files (app_name, server, features) */
+.language-zolo .token.class-name,
+.language-zspark .token.class-name {
+  color: #87d700 !important;
+  font-weight: 600;
+}
+
+/* Bifrost underscore keys in zUI files (_zClass, _zId) */
+.language-zolo .token.metadata,
+.language-zspark .token.metadata {
+  color: #00ffff !important;
+}
+
+/* Bifrost underscore keys in zUI files (_zClass, _zId) */
+.language-zolo .token.keyword,
+.language-zspark .token.keyword {
+  color: #00ffff !important;
+}
+
+/* zDispatch event keys (zDialog, zData, zCRUD, zLogin) */
+.language-zolo .token.zdispatch-event,
+.language-zspark .token.zdispatch-event {
+  color: #ffd787 !important;
+}
+
+/* zDispatch event keys (zDialog, zData, zCRUD, zLogin) */
+.language-zolo .token.dispatch-event,
+.language-zspark .token.dispatch-event {
+  color: #ffd787 !important;
+}
+
+/* UI element keys in zUI files (zImage, zText, zURL, zH1-zH6, zNavBar, zUL, zOL, zDL) */
+.language-zolo .token.display-event,
+.language-zspark .token.display-event {
+  color: #ff5f00 !important;
+  font-weight: 500;
+}
+
+/* UI element keys in zUI files (zImage, zText, zURL, zH1-zH6, zNavBar, zUL, zOL, zDL) */
+.language-zolo .token.function,
+.language-zspark .token.function {
+  color: #ff5f00 !important;
+  font-weight: 500;
+}
+
+/* Property keys inside UI elements (src, label, color) */
+.language-zolo .token.ui-property,
+.language-zspark .token.ui-property {
+  color: #af87ff !important;
+}
+
+/* Property keys inside UI elements (src, label, color) */
+.language-zolo .token.variable,
+.language-zspark .token.variable {
+  color: #af87ff !important;
+}
+
+/* Standard nested keys (host, port, ssl) */
+.language-zolo .token.property,
+.language-zspark .token.property {
+  color: #87ffaf !important;
+}
+
+/* Standard string values */
+.language-zolo .token.string,
+.language-zspark .token.string {
+  color: #fffbcb !important;
+}
+
+/* Standard string values */
+.language-zolo .token.unquoted-value,
+.language-zspark .token.unquoted-value {
+  color: #fffbcb !important;
+}
+
+/* Boolean values (true, false) */
+.language-zolo .token.boolean,
+.language-zspark .token.boolean {
+  color: #d7d7ff !important;
+}
+
+/* Numeric values (8080, 100, 3.14, -42) */
+.language-zolo .token.number,
+.language-zspark .token.number {
+  color: #FF8C00 !important;
+}
+
+/* Numeric values (8080, 100, 3.14, -42) */
+.language-zolo .token.number-value,
+.language-zspark .token.number-value {
+  color: #FF8C00 !important;
+}
+
+/* Null values (null) */
+.language-zolo .token.null,
+.language-zspark .token.null {
+  color: #d7d7ff !important;
+}
+
+/* Single-line comments (#) and inline comments */
+.language-zolo .token.comment,
+.language-zspark .token.comment {
+  color: #626262 !important;
+  font-style: italic;
+}
+
+/* Type hint text (int, bool, float, str, list, dict) */
+.language-zolo .token.type,
+.language-zspark .token.type {
+  color: #87d7ff !important;
+  font-style: italic;
+}
+
+/* Escape sequences in strings (\n, \t, \uXXXX) */
+.language-zolo .token.escape-sequence,
+.language-zspark .token.escape-sequence {
+  color: #ff0000 !important;
+}
+
+/* Colon separator (:) after root/nested keys */
+.language-zolo .token.punctuation,
+.language-zspark .token.punctuation {
+  color: #ffffff !important;
+}
+
+/* Colon separator (:) after root/nested keys */
+.language-zolo .token.modifier,
+.language-zspark .token.modifier {
+  color: #ffffff !important;
+}
+
+/* Colon separator (:) after root/nested keys */
+.language-zolo .token.operator,
+.language-zspark .token.operator {
+  color: #ffffff !important;
+}
+
+/* ============================================================================
+ * Multi-Language Support (zspark, zui, zschema, zconfig, zenv)
+ * Language-specific token styling from zlsp SSOT
+ * ============================================================================ */
+
+/* zUI-specific tokens (from SSOT: semantic-colors.json) */
+.language-zui .token.function {
+  /* zui-element: zH1, zText, zURL → uiElementKey */
+  color: #ff5f00 !important;
+  font-weight: 500;
+}
+
+.language-zui .token.variable {
+  /* zui-element-property: label, color, href → uiElementPropertyKey */
+  color: #af87ff !important;
+}
+
+.language-zui .token.keyword {
+  /* metadata: _zClass, _zId → bifrostKey */
+  color: #00ffff !important;
+}
+
+.language-zui .token.class-name {
+  /* root-key: Main_Page, Getting_Started → rootKey */
+  color: #87d700 !important;
+  font-weight: 600;
+}
+
+.language-zui .token.property {
+  /* Nested keys like Header, Actions → nestedKey */
+  color: #87ffaf !important;
+}
+
+.language-zui .token.constant {
+  /* zRBAC key → zrbacKey */
+  color: #ff0000 !important;
+  font-weight: 600;
+}
+
+/* zEnv-specific tokens */
+.language-zenv .token.constant {
+  /* zRBAC key in zEnv files → zrbacKey */
+  color: #ff0000 !important;
+  font-weight: 600;
+}
+
+.language-zenv .token.variable {
+  /* Prefix modifiers (^, ~) in zEnv → zrbacOptionKey */
+  color: #af87ff !important;
+}
+
+/* zSpark uses base zolo styles (no overrides) */
+
+/* Generic multi-language aliases (fallback for all languages) */
+.token.function {
+  color: #ff5f00 !important;
+  font-weight: 600;
+}
+
+.token.class-name {
+  color: #87d700 !important;
+  font-weight: 600;
+}
+
+/* SSOT: Type hints split into TWO tokens (value_emitters.py:352-362) */
+.token.type-hint {
+  /* Container for type hint - inherits from nested tokens */
+  color: #87d7ff !important;
+}
+
+.token.type-hint-paren {
+  /* SSOT: TokenType.TYPE_HINT_PAREN → typeHintParen → lavender */
+  color: #ffffff !important;
+}
+
+.token.type-hint-text {
+  /* SSOT: TokenType.TYPE_HINT → typeHint → dark_cyan */
+  color: #87d7ff !important;
+  font-style: italic;
+}
+
+/* Legacy support: OLD .token.type selector (before nested tokenization) */
+.token.type {
+  color: #87d7ff !important;
+  font-style: italic;
+}
+
+.token.boolean {
+  color: #d7d7ff !important;
+}
+
+.token.number {
+  color: #FF8C00 !important;
+}
+
+.token.string {
+  color: #fffbcb !important;
+}
+
+.token.punctuation {
+  color: #ffffff !important;
+}
+
+.token.operator {
+  color: #ffffff !important;
+}
+
+/* Structural brackets and braces (from Prism.js patterns) */
+.token.bracket,
+.language-zolo .token.bracket {
+  color: #ff00ff !important;
+}
+
+.token.brace,
+.language-zolo .token.brace {
+  color: #ffff00 !important;
+}
+

package/syntax/prism-zolo.js

@@ -0,0 +1,380 @@
+/**
+ * Prism.js base language definition for zolo
+ * Generic .zolo syntax - string-first philosophy
+ *
+ * This is the foundation for all specialized zolo languages.
+ * Other languages extend this base with file-type-specific patterns.
+ *
+ * Generated by zlsp/zlsp/generators/generate_prism_zolo.py
+ * DO NOT EDIT MANUALLY - regenerate with: python3 -m zlsp.generators.generate_prism_zolo
+ */
+
+Prism.languages.zolo = {
+    'comment': {
+        pattern: /(^[ \t]*#(?!>).*|#>[\s\S]*?<#)/m,
+        alias: 'comment',
+        greedy: true,
+    },
+    'root-key': {
+        pattern: /(^|\n)([a-zA-Z][a-zA-Z0-9_]*)(?=\s*(?:\([^)]+\))?[*!^~]?:)/m,
+        alias: 'class-name',
+        lookbehind: true,
+    },
+    'property': {
+        pattern: /(?<=\n)[ \t]+[a-zA-Z][a-zA-Z0-9_]*(?=\s*(?:\([^)]+\))?[*!]?:)/m,
+        lookbehind: true,
+    },
+    'type-hint': {
+        pattern: /\([^)]+\)(?=\s*:)/,
+        inside: {
+            'type-hint-paren': {
+                pattern: /[()]/,
+                alias: 'punctuation',
+            },
+            'type-hint-text': {
+                pattern: /[^()]+/,
+                alias: 'type',
+            }
+        },
+    },
+    'dash-list': {
+        pattern: /(?<=\n)[ \t]*-(?:\s+[^\n]+)?/,
+        alias: 'language-zolo',
+        lookbehind: true,
+        inside: {
+            'dash': {
+                pattern: /^[ \t]*-\s*/,
+                alias: 'bracket',
+            },
+            'object': {
+                pattern: /\{(?:[^{}]|\{[^{}]*\})*\}/,
+                alias: 'language-zolo',
+                greedy: true,
+                inside: {
+                    'brace': {
+                        pattern: /[{}]/,
+                        alias: 'brace',
+                    },
+                    'comma': {
+                        pattern: /,/,
+                        alias: 'punctuation',
+                    },
+                    'property': {
+                        pattern: /[a-zA-Z][a-zA-Z0-9_]*(?=\s*:)/,
+                        alias: 'property',
+                    },
+                    'colon': {
+                        pattern: /:/,
+                        alias: 'punctuation',
+                    },
+                    'array': {
+                        pattern: /\[(?:[^\[\]]|\[(?:[^\[\]]|\[(?:[^\[\]]|\[[^\[\]]*\])*\])*\])*\]/,
+                        alias: 'language-zolo',
+                        greedy: true,
+                        inside: {
+                            'bracket': {
+                                pattern: /[\[\]]/,
+                                alias: 'bracket',
+                            },
+                            'comma': {
+                                pattern: /,/,
+                                alias: 'punctuation',
+                            },
+                            'string': {
+                                pattern: /[^\[\],\s]+(?:\s+[^\[\],\s]+)*/,
+                                alias: 'string',
+                            }
+                        },
+                    },
+                    'boolean': {
+                        pattern: /\b(?:true|false|True|False)\b/,
+                        alias: 'boolean',
+                    },
+                    'null': {
+                        pattern: /\bnull\b/,
+                        alias: 'null',
+                    },
+                    'number': {
+                        pattern: /(?<![a-zA-Z0-9_])-?(?:0(?!\d)|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?![a-zA-Z0-9_])/,
+                        alias: 'number',
+                    },
+                    'string': {
+                        pattern: /[^{}\[\],:\s]+(?:\s+[^{}\[\],:\s]+)*/,
+                        alias: 'string',
+                    }
+                },
+            },
+            'array': {
+                pattern: /\[[^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*\]/,
+                alias: 'language-zolo',
+                inside: {
+                    'bracket': {
+                        pattern: /[\[\]]/,
+                        alias: 'bracket',
+                    },
+                    'comma': {
+                        pattern: /,/,
+                        alias: 'punctuation',
+                    },
+                    'string': {
+                        pattern: /[^\[\],\s]+(?:\s+[^\[\],\s]+)*/,
+                        alias: 'string',
+                    }
+                },
+            },
+            'string': {
+                pattern: /[^\s]+(?:\s+[^\s]+)*/,
+                alias: 'string',
+            }
+        },
+    },
+    'array': {
+        pattern: /(?<=:\s*)\[(?:[^\[\]]|\[(?:[^\[\]]|\[(?:[^\[\]]|\[[^\[\]]*\])*\])*\])*\](?=\s*(?:\n|$))/ms,
+        alias: 'language-zolo',
+        lookbehind: true,
+        greedy: true,
+        inside: {
+            'bracket': {
+                pattern: /[\[\]]/,
+                alias: 'bracket',
+            },
+            'comma': {
+                pattern: /,/,
+                alias: 'punctuation',
+            },
+            'object': {
+                pattern: /\{(?:[^{}]|\{[^{}]*\})*\}/,
+                alias: 'language-zolo',
+                greedy: true,
+                inside: {
+                    'brace': {
+                        pattern: /[{}]/,
+                        alias: 'brace',
+                    },
+                    'comma': {
+                        pattern: /,/,
+                        alias: 'punctuation',
+                    },
+                    'property': {
+                        pattern: /[a-zA-Z][a-zA-Z0-9_]*(?=\s*:)/,
+                        alias: 'property',
+                    },
+                    'colon': {
+                        pattern: /:/,
+                        alias: 'punctuation',
+                    },
+                    'array': {
+                        pattern: /\[(?:[^\[\]]|\[(?:[^\[\]]|\[(?:[^\[\]]|\[[^\[\]]*\])*\])*\])*\]/,
+                        alias: 'language-zolo',
+                        greedy: true,
+                        inside: {
+                            'bracket': {
+                                pattern: /[\[\]]/,
+                                alias: 'bracket',
+                            },
+                            'comma': {
+                                pattern: /,/,
+                                alias: 'punctuation',
+                            },
+                            'string': {
+                                pattern: /[^\[\],\s]+(?:\s+[^\[\],\s]+)*/,
+                                alias: 'string',
+                            }
+                        },
+                    },
+                    'boolean': {
+                        pattern: /\b(?:true|false|True|False)\b/,
+                        alias: 'boolean',
+                    },
+                    'null': {
+                        pattern: /\bnull\b/,
+                        alias: 'null',
+                    },
+                    'number': {
+                        pattern: /(?<![a-zA-Z0-9_])-?(?:0(?!\d)|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?![a-zA-Z0-9_])/,
+                        alias: 'number',
+                    },
+                    'string': {
+                        pattern: /[^{}\[\],:\s]+(?:\s+[^{}\[\],:\s]+)*/,
+                        alias: 'string',
+                    }
+                },
+            },
+            'nested-array': {
+                pattern: /\[(?:[^\[\]]|\[(?:[^\[\]]|\[(?:[^\[\]]|\[[^\[\]]*\])*\])*\])*\]/,
+                alias: 'language-zolo',
+                greedy: true,
+                inside: {
+                    'bracket': {
+                        pattern: /[\[\]]/,
+                        alias: 'bracket',
+                    },
+                    'comma': {
+                        pattern: /,/,
+                        alias: 'punctuation',
+                    },
+                    'string': {
+                        pattern: /[^\[\],\s]+(?:\s+[^\[\],\s]+)*/,
+                        alias: 'string',
+                    }
+                },
+            },
+            'boolean': {
+                pattern: /\b(?:true|false|True|False)\b/,
+                alias: 'boolean',
+            },
+            'null': {
+                pattern: /\bnull\b/,
+                alias: 'null',
+            },
+            'number': {
+                pattern: /(?<![a-zA-Z0-9_])-?(?:0(?!\d)|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?![a-zA-Z0-9_])/,
+                alias: 'number',
+            },
+            'string': {
+                pattern: /[^\[\],\s]+(?:\s+[^\[\],\s]+)*/,
+                alias: 'string',
+            }
+        },
+    },
+    'object': {
+        pattern: /(?<=:\s*)\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})*\}(?=\s*(?:\n|$))/m,
+        alias: 'language-zolo',
+        lookbehind: true,
+        greedy: true,
+        inside: {
+            'brace': {
+                pattern: /[{}]/,
+                alias: 'brace',
+            },
+            'comma': {
+                pattern: /,/,
+                alias: 'punctuation',
+            },
+            'property': {
+                pattern: /[a-zA-Z][a-zA-Z0-9_]*(?=\s*(?:\([^)]+\))?\s*:)/,
+                alias: 'property',
+            },
+            'type-hint': {
+                pattern: /\([^)]+\)(?=\s*:)/,
+                inside: {
+                    'type-hint-paren': {
+                        pattern: /[()]/,
+                        alias: 'punctuation',
+                    },
+                    'type-hint-text': {
+                        pattern: /[^()]+/,
+                        alias: 'type',
+                    }
+                },
+            },
+            'colon': {
+                pattern: /:/,
+                alias: 'punctuation',
+            },
+            'nested-array': {
+                pattern: /\[(?:[^\[\]]|\[(?:[^\[\]]|\[(?:[^\[\]]|\[[^\[\]]*\])*\])*\])*\]/,
+                alias: 'language-zolo',
+                greedy: true,
+                inside: {
+                    'bracket': {
+                        pattern: /[\[\]]/,
+                        alias: 'bracket',
+                    },
+                    'comma': {
+                        pattern: /,/,
+                        alias: 'punctuation',
+                    },
+                    'boolean': {
+                        pattern: /\b(?:true|false|True|False)\b/,
+                        alias: 'boolean',
+                    },
+                    'null': {
+                        pattern: /\bnull\b/,
+                        alias: 'null',
+                    },
+                    'number': {
+                        pattern: /(?<![a-zA-Z0-9_])-?(?:0(?!\d)|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?![a-zA-Z0-9_])/,
+                        alias: 'number',
+                    },
+                    'string': {
+                        pattern: /[^\[\],\s]+(?:\s+[^\[\],\s]+)*/,
+                        alias: 'string',
+                    }
+                },
+            },
+            'nested-object': {
+                pattern: /\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})*\}/,
+                alias: 'language-zolo',
+                greedy: true,
+                inside: Prism.languages.zolo,
+            },
+            'boolean': {
+                pattern: /\b(?:true|false|True|False)\b/,
+                alias: 'boolean',
+            },
+            'null': {
+                pattern: /\bnull\b/,
+                alias: 'null',
+            },
+            'number': {
+                pattern: /(?<![a-zA-Z0-9_])-?(?:0(?!\d)|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?![a-zA-Z0-9_])/,
+                alias: 'number',
+            },
+            'string': {
+                pattern: /[^{},:\s]+(?:\s+[^{},:\s]+)*/,
+                alias: 'string',
+            }
+        },
+    },
+    'boolean': {
+        pattern: /(?<=:\s+)(?:true|false|True|False)(?=\s*$)/m,
+        alias: 'boolean',
+        lookbehind: true,
+    },
+    'number': {
+        pattern: /(?<=:\s+)-?(?:0(?!\d)|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?=\s*$)/m,
+        alias: 'number',
+        lookbehind: true,
+    },
+    'null': {
+        pattern: /(?<=:\s+)null(?=\s*$)/m,
+        alias: 'null',
+        lookbehind: true,
+    },
+    'timestamp-string': {
+        pattern: /(?<=:\s+)\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[^\s]*/m,
+        alias: 'string',
+        lookbehind: true,
+    },
+    'time-string': {
+        pattern: /(?<=:\s+)\d{2}:\d{2}(?::\d{2})?(?=\s*$)/m,
+        alias: 'string',
+        lookbehind: true,
+    },
+    'version-string': {
+        pattern: /(?<=:\s+)\d+\.\d+(?:\.\d+|\.\*)+(?=\s*$)/m,
+        alias: 'string',
+        lookbehind: true,
+    },
+    'ratio-string': {
+        pattern: /(?<=:\s+)\d{1,3}:\d{1,3}(?=\s*$)/m,
+        alias: 'string',
+        lookbehind: true,
+    },
+    'string-unquoted': {
+        pattern: /(?<=:\s*)\S+(?:\s+\S+)*/m,
+        alias: 'string',
+        lookbehind: true,
+        inside: {
+            'escape-sequence': {
+                pattern: /\\[nrt\\\\"']|\\u[0-9A-Fa-f]{4}|\\U[0-9A-Fa-f]{4,8}/,
+                alias: 'constant',
+            }
+        },
+    },
+    'colon': {
+        pattern: /:/,
+        alias: 'punctuation',
+    }
+};

package/syntax/prism-zschema.js

@@ -0,0 +1,38 @@
+/**
+ * Prism.js language definition for zschema
+ * zSchema.*.zolo - Data schema definition files
+ *
+ * Extends base 'zolo' language with file-type-specific patterns.
+ *
+ * Generated by zlsp/zlsp/generators/generate_prism_zolo.py
+ * DO NOT EDIT MANUALLY - regenerate with: python3 -m zlsp.generators.generate_prism_zolo
+ */
+
+Prism.languages.zschema = Prism.languages.extend('zolo', {
+    'zschema-zmeta-root': {
+        pattern: /((?:^|\n)[ \t]*)zMeta(?=\s*:)/m,
+        alias: 'function',
+        lookbehind: true,
+    },
+    'root-key': {
+        pattern: /((?:^|\n)[ \t]*)[A-Z][a-zA-Z0-9_]*(?=\s*(?:\([^)]+\))?[*!^~]?:)/m,
+        alias: 'class-name',
+        lookbehind: true,
+    },
+    'zschema-zos-data': {
+        pattern: /(?<=\n)[ \t]{1}(?:Schema_Name|Data_Label|zMigration|Data_Source|zMigrationVersion|zUIVersion|zUITracking|Data_Type)(?=\s*:)/m,
+        alias: 'keyword',
+        lookbehind: true,
+    },
+    'zschema-property': {
+        pattern: /(?<=\n)[ \t]{2,}(?:unique|default|format|required|pattern|rules|max|pk|auto_increment|type|zHash|comment|max_length|min_length|min)(?=\s*:)/m,
+        alias: 'keyword',
+        lookbehind: true,
+    },
+    'property': {
+        pattern: /\b[a-zA-Z][a-zA-Z0-9_]*(?=\s*(?:\([^)]+\))?[*!]?:)/,
+    }
+});
+
+// Support both ```zschema and ```zSchema code fences
+Prism.languages.zSchema = Prism.languages.zschema;