naider 1.24.5 → 2.0.0

package/src/preprocess.js

@@ -1,308 +0,0 @@
-const TYPE_MAP = { s: 'str', i: 'int', n: 'num', b: 'bool', l: 'list', m: 'map', a: 'any', j: 'json', v: 'void' };
-const TYPE_CHARS = new Set(Object.keys(TYPE_MAP));
-
-function expandType(ch) { return TYPE_MAP[ch] || ch; }
-
-function expandParams(paramStr) {
-  if (!paramStr) return '';
-  return paramStr.split(',').map(p => {
-    p = p.trim();
-    if (!p) return p;
-    const m = p.match(/^(\.\.\.)?([ sinblmaj]):(.+)$/);
-    if (m) return `${m[1] || ''}${expandType(m[2])} ${m[3]}`;
-    const m2 = p.match(/^(\.\.\.)?([ sinblmaj])(\w+)$/);
-    if (m2) return `${m2[1] || ''}${expandType(m2[2])} ${m2[3]}`;
-    return p;
-  }).join(', ');
-}
-
-function transformFunc(rest, isAsync, isPublic) {
-  const pub = isPublic ? 'pub ' : '';
-  const fn = isAsync ? 'fn.async' : 'fn';
-  const nameM = rest.match(/^(\w+)/);
-  if (!nameM) return `${pub}${fn} ${rest}:`;
-  const name = nameM[1];
-  let rem = rest.slice(name.length);
-
-  let params = '';
-  if (rem.startsWith('(')) {
-    let depth = 1, i = 1;
-    while (i < rem.length && depth > 0) {
-      if (rem[i] === '(') depth++;
-      if (rem[i] === ')') depth--;
-      i++;
-    }
-    params = expandParams(rem.slice(1, i - 1));
-    rem = rem.slice(i).trim();
-  }
-
-  let retType = '';
-  if (rem.length > 0 && TYPE_CHARS.has(rem[0]) && (rem.length === 1 || !rem[1].match(/\w/))) {
-    retType = ` -> ${expandType(rem[0])}`;
-  }
-
-  return `${pub}${fn} ${name}(${params})${retType}:`;
-}
-
-function transformRoute(method, rest) {
-  const m = rest.match(/^("[^"]*")\s*(\[[^\]]*\])?\s*(\([^)]*\))?\s*(.*)$/);
-  if (!m) return `${method} ${rest}:`;
-  const path = m[1];
-  const middleware = m[2] ? ` ${m[2]}` : '';
-  const routeParams = m[3] ? ` ${m[3]}` : '';
-  const inline = m[4] ? m[4].trim() : '';
-
-  if (inline) {
-    const body = transformContent(inline);
-    return `${method} ${path}${middleware}${routeParams}:\n  ${body}`;
-  }
-  return `${method} ${path}${middleware}${routeParams}:`;
-}
-
-function transformAwait(text) {
-  // ~~ → await.all
-  text = text.replace(/~~/g, 'await.all ');
-  // ~ before identifier or ( → await (but not ~f, ~TYPE: which are handled at line level)
-  text = text.replace(/~(\w)/g, (_, ch) => `await ${ch}`);
-  text = text.replace(/~\(/g, 'await (');
-  return text;
-}
-
-function transformContent(line) {
-  // Log shorthands
-  line = line.replace(/\blog\.e\b/g, 'log.error');
-  line = line.replace(/\blog\.w\b/g, 'log.warn');
-  line = line.replace(/\blog\.i\b/g, 'log.info');
-  line = line.replace(/\blog\.d\b/g, 'log.debug');
-  // log"msg" → log "msg"
-  line = line.replace(/\blog"/g, 'log "');
-  line = line.replace(/\blog\.error"/g, 'log.error "');
-  line = line.replace(/\blog\.warn"/g, 'log.warn "');
-  line = line.replace(/\blog\.info"/g, 'log.info "');
-  line = line.replace(/\blog\.debug"/g, 'log.debug "');
-  // Await transforms
-  line = transformAwait(line);
-  return line;
-}
-
-export function preprocess(source) {
-  const lines = source.split('\n');
-  const result = [];
-
-  for (let raw of lines) {
-    const indentM = raw.match(/^(\s*)/);
-    const indent = indentM ? indentM[1] : '';
-    let line = raw.slice(indent.length);
-
-    // Empty line
-    if (!line.trim()) { result.push(''); continue; }
-
-    // Comment: -- → #
-    if (line.startsWith('--')) { result.push(indent + '#' + line.slice(2)); continue; }
-
-    // Keep # comments as-is
-    if (line.startsWith('#') && !line.startsWith('#=')) { result.push(raw); continue; }
-
-    const first = line[0];
-    const second = line[1] || '';
-    let out = '';
-
-    // > return
-    if (first === '>' && second !== '=' && second !== '>') {
-      const rest = line.slice(1).trim();
-      if (rest.startsWith('.s ') || rest.startsWith('.s(')) {
-        out = 'ret.status ' + transformContent(rest.slice(3));
-      } else if (rest.startsWith('.r ')) {
-        out = 'ret.redirect ' + transformContent(rest.slice(3));
-      } else if (rest.startsWith('.h ')) {
-        out = 'ret.html ' + transformContent(rest.slice(3));
-      } else if (rest.startsWith('.t ')) {
-        out = 'ret.text ' + transformContent(rest.slice(3));
-      } else if (rest.startsWith('.f ')) {
-        out = 'ret.file ' + transformContent(rest.slice(3));
-      } else if (rest.startsWith('.v ')) {
-        out = 'ret.render ' + transformContent(rest.slice(3));
-      } else if (rest.startsWith('.d ')) {
-        out = 'ret.download ' + transformContent(rest.slice(3));
-      } else {
-        out = rest ? 'ret ' + transformContent(rest) : 'ret';
-      }
-    }
-    // ? if
-    else if (first === '?' && second !== '.' && second !== '?') {
-      out = 'if ' + transformContent(line.slice(1).trim()) + ':';
-    }
-    // | elif (but not |>)
-    else if (first === '|' && second !== '>') {
-      out = 'elif ' + transformContent(line.slice(1).trim()) + ':';
-    }
-    // : else (alone on line)
-    else if (line.trim() === ':') {
-      out = 'else:';
-    }
-    // @ loop
-    else if (first === '@') {
-      const rest = line.slice(1);
-      const loopM = rest.match(/^(\w+(?:,\w+)?)<(.+)$/);
-      if (loopM) {
-        const vars = loopM[1];
-        const col = transformContent(loopM[2]);
-        if (col.includes('..')) {
-          const [start, end] = col.split('..');
-          out = `for ${vars} in ${start}..${end}:`;
-        } else if (vars.includes(',')) {
-          const [k, v] = vars.split(',');
-          out = `each ${k}, ${v} in ${col}:`;
-        } else {
-          out = `each ${vars} in ${col}:`;
-        }
-      } else {
-        out = transformContent(line);
-      }
-    }
-    // * while
-    else if (first === '*') {
-      out = 'while ' + transformContent(line.slice(1).trim()) + ':';
-    }
-    // !!! ensure/finally (before !! and ! checks)
-    else if (first === '!' && second === '!' && (line[2] || '') === '!') {
-      out = 'ensure:';
-    }
-    // !! catch (before ! try check)
-    else if (first === '!' && second === '!') {
-      const rest = line.slice(2).trim();
-      out = rest ? `fail ${rest}:` : 'fail:';
-    }
-    // ! try (alone)
-    else if (line.trim() === '!') {
-      out = 'try:';
-    }
-    // $ server
-    else if (first === '$') {
-      const rest = line.slice(1);
-      const srvM = rest.match(/^(\w+):(.+)$/);
-      if (srvM) {
-        out = `server ${srvM[1]} port ${transformContent(srvM[2].trim())}:`;
-      } else {
-        out = `server ${rest.trim()}:`;
-      }
-    }
-    // HTTP routes: G P U D
-    else if (first === 'G' && second === '"') { out = transformRoute('get', line.slice(1)); }
-    else if (first === 'P' && second === '"') { out = transformRoute('post', line.slice(1)); }
-    else if (first === 'U' && second === '"') { out = transformRoute('put', line.slice(1)); }
-    else if (first === 'D' && second === '"') { out = transformRoute('del', line.slice(1)); }
-    else if (first === 'X' && second === '"') { out = transformRoute('patch', line.slice(1)); }
-    // ^ model
-    else if (first === '^') {
-      const rest = line.slice(1).trim();
-      const extM = rest.match(/^(\w+)<(\w+)$/);
-      if (extM) {
-        out = `model ${extM[1]} extends ${extM[2]}:`;
-      } else {
-        out = `model ${rest}:`;
-      }
-    }
-    // < import
-    else if (first === '<') {
-      const rest = line.slice(1);
-      if (rest.startsWith('{')) {
-        const impM = rest.match(/^\{([^}]+)\}"(.+)"$/);
-        if (impM) {
-          out = `use {${impM[1]}} from "${impM[2]}"`;
-        } else {
-          out = transformContent(line);
-        }
-      } else {
-        const fromM = rest.match(/^(\w+)"(.+)"$/);
-        if (fromM) {
-          out = `use ${fromM[1]} from "${fromM[2]}"`;
-        } else {
-          out = `use ${rest.trim()}`;
-        }
-      }
-    }
-    // % match
-    else if (first === '%') {
-      out = 'match ' + transformContent(line.slice(1).trim()) + ':';
-    }
-    // + export prefix
-    else if (first === '+') {
-      const inner = line.slice(1);
-      if (inner.startsWith('~f ')) {
-        out = transformFunc(inner.slice(3), true, true);
-      } else if (inner.startsWith('f ')) {
-        out = transformFunc(inner.slice(2), false, true);
-      } else {
-        const tvM = inner.match(/^([sinblmaj]):(\w+)=(.+)$/);
-        if (tvM) {
-          out = `pub ${expandType(tvM[1])} ${tvM[2]} = ${transformContent(tvM[3])}`;
-        } else {
-          out = 'pub ' + transformContent(inner);
-        }
-      }
-    }
-    // ~f async function
-    else if (first === '~' && second === 'f' && line[2] === ' ') {
-      out = transformFunc(line.slice(3), true, false);
-    }
-    // ~TYPE:name=value → mutable
-    else if (first === '~' && TYPE_CHARS.has(second) && line[2] === ':') {
-      const rest = line.slice(1);
-      const tvM = rest.match(/^([sinblmaj]):(\w+)=(.+)$/);
-      if (tvM) {
-        out = `mut ${expandType(tvM[1])} ${tvM[2]} = ${transformContent(tvM[3])}`;
-      } else {
-        // Mutable field without assignment: ~s:name
-        const fieldM = rest.match(/^([sinblmaj]):(\w+)$/);
-        if (fieldM) {
-          out = `mut ${expandType(fieldM[1])} ${fieldM[2]}`;
-        } else {
-          out = transformContent(line);
-        }
-      }
-    }
-    // f function
-    else if (first === 'f' && second === ' ') {
-      out = transformFunc(line.slice(2), false, false);
-    }
-    // TYPE:name=value → typed variable
-    else if (TYPE_CHARS.has(first) && second === ':') {
-      const rest = line;
-      const tvM = rest.match(/^([sinblmaj]):(\w+)=(.+)$/);
-      if (tvM) {
-        out = `${expandType(tvM[1])} ${tvM[2]} = ${transformContent(tvM[3])}`;
-      } else {
-        // Could be a type field in model: s:name (no assignment)
-        const fieldM = rest.match(/^([sinblmaj]):(\w+)$/);
-        if (fieldM) {
-          out = `${expandType(fieldM[1])} ${fieldM[2]}`;
-        } else {
-          // type:name=... with complex value
-          const fieldDefM = rest.match(/^([sinblmaj]):(\w+)=(.+)$/);
-          if (fieldDefM) {
-            out = `${expandType(fieldDefM[1])} ${fieldDefM[2]} = ${transformContent(fieldDefM[3])}`;
-          } else {
-            out = transformContent(line);
-          }
-        }
-      }
-    }
-    // Default: apply inline transforms
-    else {
-      out = transformContent(line);
-    }
-
-    // Handle multi-line output from route transform
-    if (out.includes('\n')) {
-      const subLines = out.split('\n');
-      for (const sl of subLines) {
-        result.push(indent + sl);
-      }
-    } else {
-      result.push(indent + out);
-    }
-  }
-
-  return result.join('\n');
-}

package/vscode-naide/language-configuration-nx.json

@@ -1,32 +0,0 @@
-{
-  "comments": {
-    "lineComment": "--"
-  },
-  "brackets": [
-    ["{", "}"],
-    ["[", "]"],
-    ["(", ")"]
-  ],
-  "autoClosingPairs": [
-    { "open": "{", "close": "}" },
-    { "open": "[", "close": "]" },
-    { "open": "(", "close": ")" },
-    { "open": "\"", "close": "\"" },
-    { "open": "'", "close": "'" }
-  ],
-  "surroundingPairs": [
-    { "open": "{", "close": "}" },
-    { "open": "[", "close": "]" },
-    { "open": "(", "close": ")" },
-    { "open": "\"", "close": "\"" },
-    { "open": "'", "close": "'" }
-  ],
-  "indentationRules": {
-    "increaseIndentPattern": "^\\s*(fn|fn\\.async|if|elif|else|each|for|while|match|try|fail|ensure|server|model|on|schema|crud|auth|env|every|watch|ws|group|upload|queue|job|test|get|post|put|del|patch|error|sse|view|cache|mid|validate|openapi|static|session|cookie|cors|limit)\\b.*:\\s*$",
-    "decreaseIndentPattern": "^\\s*(elif|else|fail|ensure)\\b"
-  },
-  "folding": {
-    "offSide": true
-  },
-  "wordPattern": "(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)"
-}

package/vscode-naide/syntaxes/naidex.tmLanguage.json

@@ -1,287 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
-  "name": "NAIDE-X",
-  "scopeName": "source.naidex",
-  "patterns": [
-    { "include": "#comments" },
-    { "include": "#strings" },
-    { "include": "#numbers" },
-    { "include": "#constants" },
-    { "include": "#storage" },
-    { "include": "#types-short" },
-    { "include": "#types" },
-    { "include": "#nx-prefixes" },
-    { "include": "#keywords-control" },
-    { "include": "#keywords-server" },
-    { "include": "#keywords-declaration" },
-    { "include": "#keywords-operator" },
-    { "include": "#schema-modifiers" },
-    { "include": "#builtins" },
-    { "include": "#function-def" },
-    { "include": "#operators" },
-    { "include": "#punctuation" }
-  ],
-  "repository": {
-    "comments": {
-      "match": "--.*$",
-      "name": "comment.line.double-dash.naidex"
-    },
-    "strings": {
-      "patterns": [
-        {
-          "name": "string.quoted.double.naidex",
-          "begin": "\"",
-          "end": "\"",
-          "patterns": [
-            {
-              "name": "constant.character.escape.naidex",
-              "match": "\\\\."
-            },
-            {
-              "name": "meta.embedded.expression.naidex",
-              "begin": "\\{",
-              "end": "\\}",
-              "beginCaptures": { "0": { "name": "punctuation.definition.interpolation.begin.naidex" } },
-              "endCaptures": { "0": { "name": "punctuation.definition.interpolation.end.naidex" } },
-              "patterns": [
-                { "include": "#numbers" },
-                { "include": "#constants" },
-                {
-                  "name": "variable.other.naidex",
-                  "match": "[a-zA-Z_][a-zA-Z0-9_.]*"
-                }
-              ]
-            }
-          ]
-        },
-        {
-          "name": "string.quoted.single.naidex",
-          "begin": "'",
-          "end": "'",
-          "patterns": [
-            {
-              "name": "constant.character.escape.naidex",
-              "match": "\\\\."
-            }
-          ]
-        }
-      ]
-    },
-    "numbers": {
-      "match": "\\b\\d+(\\.\\d+)?\\b",
-      "name": "constant.numeric.naidex"
-    },
-    "constants": {
-      "match": "\\b(true|false|null|self)\\b",
-      "name": "constant.language.naidex"
-    },
-    "storage": {
-      "match": "\\b(mut|pub)\\b|(?<=^\\s*)~(?=[a-z]:)",
-      "name": "storage.modifier.naidex"
-    },
-    "types-short": {
-      "match": "(?<=^\\s*~?)([sinblma])(?=:)",
-      "name": "support.type.naidex"
-    },
-    "types": {
-      "match": "\\b(str|int|num|bool|list|map|any|json|void)\\b",
-      "name": "support.type.naidex"
-    },
-    "nx-prefixes": {
-      "patterns": [
-        {
-          "match": "^\\s*>",
-          "name": "keyword.control.return.naidex"
-        },
-        {
-          "match": "^\\s*\\?(?!\\.)",
-          "name": "keyword.control.if.naidex"
-        },
-        {
-          "match": "^\\s*\\|(?!>)",
-          "name": "keyword.control.elif.naidex"
-        },
-        {
-          "match": "^\\s*:(?!=)",
-          "name": "keyword.control.else.naidex"
-        },
-        {
-          "match": "^\\s*@",
-          "name": "keyword.control.loop.naidex"
-        },
-        {
-          "match": "^\\s*\\*",
-          "name": "keyword.control.while.naidex"
-        },
-        {
-          "match": "^\\s*!!!",
-          "name": "keyword.control.ensure.naidex"
-        },
-        {
-          "match": "^\\s*!!",
-          "name": "keyword.control.catch.naidex"
-        },
-        {
-          "match": "^\\s*!(?!!)",
-          "name": "keyword.control.try.naidex"
-        },
-        {
-          "match": "^\\s*\\$",
-          "name": "keyword.other.server.naidex"
-        },
-        {
-          "match": "^\\s*\\^",
-          "name": "keyword.declaration.model.naidex"
-        },
-        {
-          "match": "^\\s*<",
-          "name": "keyword.declaration.import.naidex"
-        },
-        {
-          "match": "^\\s*%",
-          "name": "keyword.control.match.naidex"
-        },
-        {
-          "match": "^\\s*\\+",
-          "name": "storage.modifier.export.naidex"
-        },
-        {
-          "match": "^\\s*~f\\b",
-          "name": "keyword.declaration.async-function.naidex"
-        },
-        {
-          "match": "^\\s*f\\b",
-          "name": "keyword.declaration.function.naidex"
-        },
-        {
-          "match": "^\\s*G(?=\")",
-          "name": "keyword.other.get.naidex"
-        },
-        {
-          "match": "^\\s*P(?=\")",
-          "name": "keyword.other.post.naidex"
-        },
-        {
-          "match": "^\\s*U(?=\")",
-          "name": "keyword.other.put.naidex"
-        },
-        {
-          "match": "^\\s*D(?=\")",
-          "name": "keyword.other.delete.naidex"
-        },
-        {
-          "match": "^\\s*X(?=\")",
-          "name": "keyword.other.patch.naidex"
-        }
-      ]
-    },
-    "keywords-control": {
-      "match": "\\b(if|elif|else|each|for|while|in|match|try|fail|ensure|ret|break|continue|throw|then|not|and|or|typeof|instanceof)\\b",
-      "name": "keyword.control.naidex"
-    },
-    "keywords-server": {
-      "match": "\\b(server|get|post|put|del|patch|mid|cors|limit|auth|crud|static|ws|sse|group|upload|cookie|session|view|cache|validate|openapi|error|on)\\b",
-      "name": "keyword.other.naidex"
-    },
-    "keywords-declaration": {
-      "match": "\\b(fn|fn\\.async|use|from|as|model|extends|schema|env|db|every|watch|test|assert|queue|job|new)\\b",
-      "name": "keyword.declaration.naidex"
-    },
-    "keywords-operator": {
-      "match": "\\b(await|await\\.all)\\b|~~|~(?=[a-zA-Z(])",
-      "name": "keyword.operator.naidex"
-    },
-    "schema-modifiers": {
-      "match": "\\b(required|optional|unique|auto|timestamp)\\b",
-      "name": "support.other.naidex"
-    },
-    "builtins": {
-      "patterns": [
-        {
-          "match": "\\b(log|log\\.e|log\\.w|log\\.i|log\\.d|log\\.error|log\\.warn|log\\.info|log\\.debug)\\b",
-          "name": "support.function.naidex"
-        },
-        {
-          "match": "\\b(uuid|hash|verify|sign)\\b(?=\\s*\\()",
-          "name": "support.function.naidex"
-        },
-        {
-          "match": "\\b(api)\\.(get|post|put|del|raw)\\b",
-          "name": "support.function.naidex"
-        },
-        {
-          "match": ">\\.([shrtvdf])\\b",
-          "name": "keyword.control.naidex"
-        },
-        {
-          "match": "\\b(min|max|default|email|url|enum)\\b(?=\\s*\\()",
-          "name": "support.function.naidex"
-        },
-        {
-          "match": "\\b(send|broadcast|next)\\b(?=\\s*\\()",
-          "name": "support.function.naidex"
-        }
-      ]
-    },
-    "function-def": {
-      "match": "(?<=\\bf\\s|\\bfn\\s|\\bfn\\.async\\s|~f\\s)([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=\\()",
-      "captures": {
-        "1": { "name": "entity.name.function.naidex" }
-      }
-    },
-    "operators": {
-      "patterns": [
-        {
-          "match": "\\|>",
-          "name": "keyword.operator.pipe.naidex"
-        },
-        {
-          "match": "=>",
-          "name": "keyword.operator.arrow.naidex"
-        },
-        {
-          "match": "->",
-          "name": "keyword.operator.return-type.naidex"
-        },
-        {
-          "match": "\\?\\.|\\.\\.",
-          "name": "keyword.operator.naidex"
-        },
-        {
-          "match": "\\?\\?",
-          "name": "keyword.operator.nullish.naidex"
-        },
-        {
-          "match": "\\.\\.\\.",
-          "name": "keyword.operator.spread.naidex"
-        },
-        {
-          "match": "==|!=|>=|<=|>|<",
-          "name": "keyword.operator.comparison.naidex"
-        },
-        {
-          "match": "\\+=|-=",
-          "name": "keyword.operator.assignment.compound.naidex"
-        },
-        {
-          "match": "=",
-          "name": "keyword.operator.assignment.naidex"
-        },
-        {
-          "match": "[+\\-*/%]",
-          "name": "keyword.operator.arithmetic.naidex"
-        }
-      ]
-    },
-    "punctuation": {
-      "patterns": [
-        { "match": ":", "name": "punctuation.separator.naidex" },
-        { "match": ",", "name": "punctuation.separator.comma.naidex" },
-        { "match": "\\.", "name": "punctuation.accessor.naidex" },
-        { "match": "[\\(\\)]", "name": "punctuation.paren.naidex" },
-        { "match": "[\\[\\]]", "name": "punctuation.bracket.naidex" },
-        { "match": "[\\{\\}]", "name": "punctuation.brace.naidex" }
-      ]
-    }
-  }
-}