@slim-lang/core 1.2.0

package/src/jsdoc.js

@@ -0,0 +1,273 @@
+import _traverse from "@babel/traverse"
+import * as t from "@babel/types"
+
+const traverse = _traverse.default ?? _traverse
+
+const PRIMITIVES = {
+    int: "number", float: "number", number: "number",
+    string: "string", bool: "boolean", null: "null",
+    any: "any", object: "object", array: "any[]",
+    function: "Function", element: "HTMLElement"
+}
+
+function mapType(label) {
+    label = String(label).trim()
+    if (!label) return "any"
+    if (label.length > 2 && label.startsWith("[") && label.endsWith("]")) {
+        return `[${label.slice(1, -1).split(",").map(part => mapType(part.trim())).join(", ")}]`
+    }
+    if (label.endsWith("?")) return mapType(label.slice(0, -1)) + " | null | undefined"
+    if (label.endsWith("[]")) return mapType(label.slice(0, -2)) + "[]"
+    if (label.includes("|")) return [...new Set(label.split("|").map(mapType))].join(" | ")
+    if (label.includes("&")) return [...new Set(label.split("&").map(mapType))].join(" & ")
+    if (label.includes("::")) return "number | string"
+    return PRIMITIVES[label] ?? label
+}
+
+export function jsdocComment(lines) {
+    return "*\n" + lines.map(line => ` * ${line}`).join("\n") + "\n "
+}
+
+function enumTypedef(name, schema) {
+    const types = new Set()
+
+    for (const property of schema.properties) {
+        if (!t.isObjectProperty(property)) continue
+        if (t.isStringLiteral(property.value)) types.add("string")
+        else types.add("number")
+    }
+
+    const type = types.size ? [...types].join(" | ") : "number | string"
+    return `@typedef {${type}} ${name}`
+}
+
+function structTypedef(name, schema) {
+    const fields = []
+
+    for (const property of schema.properties) {
+        if (!t.isObjectProperty(property) || !t.isStringLiteral(property.value)) continue
+
+        const rawKey = t.isStringLiteral(property.key)
+            ? property.key.value
+            : t.isIdentifier(property.key)
+                ? property.key.name
+                : null
+        if (rawKey === null) continue
+
+        const optional = rawKey.startsWith("*")
+        const field = optional ? rawKey.slice(1).trim() : rawKey
+        fields.push(`${field}${optional ? "?" : ""}: ${mapType(property.value.value)}`)
+    }
+
+    return `@typedef {{ ${fields.join(", ")} }} ${name}`
+}
+
+function returnLabel(fn) {
+    if (!t.isBlockStatement(fn.body)) return null
+
+    for (const statement of fn.body.body) {
+        if (!t.isExpressionStatement(statement)) continue
+        const call = statement.expression
+        if (!t.isCallExpression(call) || !t.isIdentifier(call.callee, { name: "__declare_return__" })) continue
+        if (t.isStringLiteral(call.arguments[0])) return call.arguments[0].value
+    }
+    return null
+}
+
+function paramLines(fn) {
+    if (!t.isBlockStatement(fn.body)) return []
+
+    const lines = []
+    for (const statement of fn.body.body) {
+        if (!t.isExpressionStatement(statement)) continue
+        const call = statement.expression
+        if (!t.isCallExpression(call) || !t.isIdentifier(call.callee, { name: "__typed_parameter__" })) continue
+
+        const [value, typeArg] = call.arguments
+        if (!t.isIdentifier(value) || !t.isStringLiteral(typeArg)) continue
+
+        lines.push(`@param {${mapType(typeArg.value)}} ${value.name}`)
+    }
+
+    const returns = returnLabel(fn)
+    if (returns) {
+        const asyncReturn = fn.async ? `Promise<${mapType(returns)}>` : mapType(returns)
+        lines.push(`@returns {${asyncReturn}}`)
+    }
+
+    return lines
+}
+
+function structInterface(schema) {
+    const fields = []
+
+    for (const property of schema.properties) {
+        if (!t.isObjectProperty(property) || !t.isStringLiteral(property.value)) continue
+
+        const rawKey = t.isStringLiteral(property.key)
+            ? property.key.value
+            : t.isIdentifier(property.key)
+                ? property.key.name
+                : null
+        if (rawKey === null) continue
+
+        const optional = rawKey.startsWith("*")
+        const field = optional ? rawKey.slice(1).trim() : rawKey
+        fields.push(`${field}${optional ? "?" : ""}: ${mapType(property.value.value)}`)
+    }
+
+    return `{ ${fields.join("; ")} }`
+}
+
+function enumValueType(schema) {
+    const types = new Set()
+    for (const property of schema.properties) {
+        if (!t.isObjectProperty(property)) continue
+        types.add(t.isStringLiteral(property.value) ? "string" : "number")
+    }
+    return types.size ? [...types].join(" | ") : "number | string"
+}
+
+function paramTypes(fn) {
+    const types = new Map()
+    if (!t.isBlockStatement(fn.body)) return types
+
+    for (const statement of fn.body.body) {
+        if (!t.isExpressionStatement(statement)) continue
+        const call = statement.expression
+        if (!t.isCallExpression(call) || !t.isIdentifier(call.callee, { name: "__typed_parameter__" })) continue
+
+        const [value, typeArg] = call.arguments
+        if (t.isIdentifier(value) && t.isStringLiteral(typeArg)) types.set(value.name, typeArg.value)
+    }
+    return types
+}
+
+function functionSignature(name, fn) {
+    const types = paramTypes(fn)
+
+    const params = fn.params.map(param => {
+        if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+            const label = types.get(param.left.name)
+            return `${param.left.name}?: ${label ? mapType(label) : "any"}`
+        }
+        if (t.isRestElement(param) && t.isIdentifier(param.argument)) {
+            return `...${param.argument.name}: any[]`
+        }
+        if (t.isIdentifier(param)) {
+            const label = types.get(param.name)
+            return `${param.name}: ${label ? mapType(label) : "any"}`
+        }
+        return "arg: any"
+    })
+
+    const returns = returnLabel(fn)
+    const result = returns
+        ? (fn.async ? `Promise<${mapType(returns)}>` : mapType(returns))
+        : "any"
+
+    return `export declare function ${name}(${params.join(", ")}): ${result}`
+}
+
+export function emitDeclarations(ast) {
+    const lines = []
+    let usesStruct = false
+
+    traverse(ast, {
+        ExportNamedDeclaration(path_) {
+            const decl = path_.node.declaration
+            if (!decl) return
+
+            if (t.isFunctionDeclaration(decl) && decl.id) {
+                lines.push(functionSignature(decl.id.name, decl))
+                return
+            }
+
+            if (!t.isVariableDeclaration(decl)) return
+
+            for (const declarator of decl.declarations) {
+                if (!t.isIdentifier(declarator.id)) continue
+                const name = declarator.id.name
+                const init = declarator.init
+
+                if (t.isArrowFunctionExpression(init) || t.isFunctionExpression(init)) {
+                    lines.push(functionSignature(name, init))
+                    continue
+                }
+
+                if (!t.isCallExpression(init)) continue
+
+                if (t.isIdentifier(init.callee, { name: "__def_struct__" }) && t.isObjectExpression(init.arguments[1])) {
+                    usesStruct = true
+                    lines.push(`export interface ${name} ${structInterface(init.arguments[1])}`)
+                    lines.push(`export declare const ${name}: SlimStruct<${name}>`)
+                } else if (t.isIdentifier(init.callee, { name: "__def_enum__" }) && t.isObjectExpression(init.arguments[1])) {
+                    lines.push(`export type ${name} = ${enumValueType(init.arguments[1])}`)
+                    lines.push(`export declare const ${name}: Record<string, any>`)
+                } else if (t.isIdentifier(init.callee, { name: "__type_def__" })) {
+                    lines.push(`export type ${name} = any`)
+                    lines.push(`export declare const ${name}: (value: unknown) => boolean`)
+                }
+            }
+        }
+    })
+
+    if (lines.length === 0) return null
+
+    const header = usesStruct
+        ? "type SlimStruct<T> = { verify(value: unknown): T; verifySafe(value: unknown): { success: boolean; result: T } }\n\n"
+        : ""
+
+    return header + lines.join("\n") + "\n"
+}
+
+export function emitJsDoc(ast) {
+    const typedefs = []
+
+    traverse(ast, {
+        VariableDeclaration(path_) {
+            for (const declarator of path_.node.declarations) {
+                const init = declarator.init
+                if (!t.isCallExpression(init)) continue
+
+                if (t.isIdentifier(init.callee, { name: "__def_struct__" }) &&
+                    t.isStringLiteral(init.arguments[0]) &&
+                    t.isObjectExpression(init.arguments[1])) {
+                    typedefs.push(structTypedef(init.arguments[0].value, init.arguments[1]))
+                }
+
+                if (t.isIdentifier(init.callee, { name: "__def_enum__" }) &&
+                    t.isStringLiteral(init.arguments[0]) &&
+                    t.isObjectExpression(init.arguments[1])) {
+                    typedefs.push(enumTypedef(init.arguments[0].value, init.arguments[1]))
+                }
+
+                if (t.isIdentifier(init.callee, { name: "__type_def__" }) &&
+                    t.isStringLiteral(init.arguments[0])) {
+                    typedefs.push(`@typedef {any} ${init.arguments[0].value}`)
+                }
+
+                if (t.isIdentifier(init.callee, { name: "__typed_variable__" }) &&
+                    t.isStringLiteral(init.arguments[1])) {
+                    t.addComment(path_.node, "leading",
+                        jsdocComment([`@type {${mapType(init.arguments[1].value)}}`]), false)
+                }
+            }
+        },
+
+        Function(path_) {
+            const lines = paramLines(path_.node)
+            if (lines.length === 0) return
+
+            const target = t.isFunctionDeclaration(path_.node)
+                ? path_.node
+                : path_.parentPath.isVariableDeclarator()
+                    ? path_.parentPath.parentPath.node
+                    : path_.node
+
+            t.addComment(target, "leading", jsdocComment(lines), false)
+        }
+    })
+
+    return typedefs
+}

package/src/lexer.js

@@ -0,0 +1,174 @@
+const KEYWORDS = new Set([
+    "struct", "enum", "type", "func", "component", "use", "lock", "mode", "elif",
+    "and", "or", "sizeof", "kindof", "empty", "copyof",
+    "break", "case", "catch", "class", "const", "continue", "debugger", "default",
+    "delete", "do", "else", "export", "extends", "finally", "for", "function",
+    "if", "import", "in", "instanceof", "new", "return", "super", "switch", "this",
+    "throw", "try", "typeof", "var", "void", "while", "with", "yield", "let",
+    "static", "async", "await", "of", "as", "from"
+])
+
+const REGEX_KEYWORDS = new Set([
+    "return", "typeof", "instanceof", "in", "of", "new", "delete", "void",
+    "do", "else", "yield", "await", "case", "throw"
+])
+
+const PUNCTUATORS = [
+    ">>>=", "===", "!==", ">>>", "**=", "<<=", ">>=", "&&=", "||=", "??=", "...",
+    "~/", "::", "=>", "==", "!=", "<=", ">=", "&&", "||", "??", "?.", "**", "++",
+    "--", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<", ">>",
+    "{", "}", "(", ")", "[", "]", ";", ",", "<", ">", "+", "-", "*", "/", "%",
+    "&", "|", "^", "!", "~", "?", ":", "=", ".", "@"
+]
+
+const NUMBER = /(?:0[xX][0-9a-fA-F_]+|0[oO][0-7_]+|0[bB][01_]+|(?:\d[\d_]*)?\.?\d[\d_]*(?:[eE][+-]?\d+)?)n?/y
+const NAME = /[A-Za-z_$][\w$]*/y
+
+function regexAllowed(prev) {
+    if (!prev) return true
+    if (prev.type === "number" || prev.type === "string" || prev.type === "regex" || prev.type === "template") {
+        return false
+    }
+    if (prev.type === "name") {
+        return prev.keyword && REGEX_KEYWORDS.has(prev.value)
+    }
+    if (prev.type === "punct") {
+        return prev.value !== ")" && prev.value !== "]"
+    }
+    return true
+}
+
+function scanRegex(code, start) {
+    let i = start + 1
+    let inClass = false
+
+    while (i < code.length) {
+        const c = code[i]
+        if (c === "\n") return start
+        if (c === "\\") { i += 2; continue }
+        if (c === "[") inClass = true
+        else if (c === "]") inClass = false
+        else if (c === "/" && !inClass) { i++; break }
+        i++
+    }
+
+    if (i > code.length) return start
+    while (i < code.length && /[a-z]/i.test(code[i])) i++
+    return i
+}
+
+export function tokenize(code) {
+    const tokens = []
+    const modes = [{ kind: "code", brace: 0, interp: false }]
+    let prev = null
+    let i = 0
+
+    const emit = (type, start, end, keyword = false) => {
+        const token = { type, value: code.slice(start, end), start, end }
+        if (keyword) token.keyword = true
+        tokens.push(token)
+        if (type !== "ws" && type !== "newline" && type !== "comment") prev = token
+        return token
+    }
+
+    while (i < code.length) {
+        const mode = modes[modes.length - 1]
+
+        if (mode.kind === "template") {
+            const start = i
+            while (i < code.length) {
+                const c = code[i]
+                if (c === "\\") { i += 2; continue }
+                if (c === "`" || (c === "$" && code[i + 1] === "{")) break
+                i++
+            }
+            if (i > start) emit("template", start, i)
+
+            if (code[i] === "`") {
+                emit("punct", i, i + 1); i++
+                modes.pop()
+            } else if (code[i] === "$") {
+                emit("punct", i, i + 2); i += 2
+                modes.push({ kind: "code", brace: 0, interp: true })
+            }
+            continue
+        }
+
+        const c = code[i]
+
+        if (c === " " || c === "\t" || c === "\r") {
+            const start = i
+            while (i < code.length && (code[i] === " " || code[i] === "\t" || code[i] === "\r")) i++
+            emit("ws", start, i); continue
+        }
+
+        if (c === "\n") { emit("newline", i, i + 1); i++; continue }
+
+        if (c === "/" && code[i + 1] === "/") {
+            const start = i
+            while (i < code.length && code[i] !== "\n") i++
+            emit("comment", start, i); continue
+        }
+
+        if (c === "/" && code[i + 1] === "*") {
+            const start = i
+            i += 2
+            while (i < code.length && !(code[i] === "*" && code[i + 1] === "/")) i++
+            i = Math.min(i + 2, code.length)
+            emit("comment", start, i); continue
+        }
+
+        if (c === "'" || c === '"') {
+            const start = i
+            i++
+            while (i < code.length) {
+                if (code[i] === "\\") { i += 2; continue }
+                if (code[i] === c || code[i] === "\n") { break }
+                i++
+            }
+            if (code[i] === c) i++
+            emit("string", start, i); continue
+        }
+
+        if (c === "`") {
+            emit("punct", i, i + 1); i++
+            modes.push({ kind: "template" }); continue
+        }
+
+        if (c === "}" && mode.interp && mode.brace === 0) {
+            emit("punct", i, i + 1); i++
+            modes.pop(); continue
+        }
+        if (c === "{" && mode.interp) mode.brace++
+        if (c === "}" && mode.interp) mode.brace--
+
+        if (c === "/" && regexAllowed(prev)) {
+            const end = scanRegex(code, i)
+            if (end > i) { emit("regex", i, end); i = end; continue }
+        }
+
+        NUMBER.lastIndex = i
+        const num = NUMBER.exec(code)
+        if (num && num.index === i && num[0].length > 0) {
+            emit("number", i, i + num[0].length); i += num[0].length; continue
+        }
+
+        NAME.lastIndex = i
+        const name = NAME.exec(code)
+        if (name && name.index === i) {
+            emit("name", i, i + name[0].length, KEYWORDS.has(name[0])); i += name[0].length; continue
+        }
+
+        let matched = null
+        for (const p of PUNCTUATORS) {
+            if (code.startsWith(p, i)) { matched = p; break }
+        }
+        if (matched) {
+            emit("punct", i, i + matched.length); i += matched.length; continue
+        }
+
+        emit("other", i, i + 1); i++
+    }
+
+    return tokens
+}

package/src/modulePaths.js

@@ -0,0 +1,74 @@
+import fs from "node:fs"
+import path from "node:path"
+import { isBuiltin } from "node:module"
+
+const slimExtension = ".slim"
+
+function isWithin(parent, target) {
+    const relative = path.relative(parent, target)
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
+}
+
+function bareName(raw) {
+    const segments = raw.split("/")
+    return raw.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0]
+}
+
+function isNodeModule(raw) {
+    if (raw.startsWith(".") || path.isAbsolute(raw)) return false
+    return fs.existsSync(path.resolve("node_modules", bareName(raw)))
+}
+
+export function getDistPath(slimFile) {
+    const abs = path.resolve(slimFile)
+    const srcRoot = path.resolve("src")
+    const projectRoot = path.resolve(".")
+    const relative = isWithin(srcRoot, abs)
+        ? path.relative(srcRoot, abs)
+        : path.relative(projectRoot, abs)
+
+    return path.resolve("dist", relative.replace(/\.slim$/, ".js"))
+}
+
+export function resolveSlimSource(raw, fromFile) {
+    // Node builtins (e.g. "node:crypto", "fs", "path") are not Slim sources;
+    // leave them for the JS import to resolve untouched.
+    if (isBuiltin(raw)) return null
+
+    if (raw.startsWith("@")) {
+        const packagesRoot = path.resolve("packages")
+        const packageName = raw.slice("@".length)
+        const fileSource = path.resolve(packagesRoot, packageName + slimExtension)
+
+        if (fs.existsSync(fileSource)) return fileSource
+
+        const directorySource = path.resolve(packagesRoot, packageName, "main.slim")
+        if (fs.existsSync(directorySource)) return directorySource
+
+        if (isNodeModule(raw)) return null
+
+        return fileSource
+    }
+
+    if (raw.endsWith(".js")) return null
+
+    const localSource = path.resolve(path.dirname(fromFile), raw + slimExtension)
+    if (fs.existsSync(localSource)) return localSource
+
+    if (isNodeModule(raw)) return null
+
+    return localSource
+}
+
+export function resolveSlimImport(raw, fromFile) {
+    if (raw.endsWith(".js")) return raw
+
+    const slimSource = resolveSlimSource(raw, fromFile)
+    if (slimSource === null) return raw
+
+    const distTarget = getDistPath(slimSource)
+    const distFrom = getDistPath(fromFile)
+    const relative = path.relative(path.dirname(distFrom), distTarget).replace(/\\/g, "/")
+
+    return relative.startsWith(".") ? relative : "./" + relative
+}