@slim-lang/core 1.2.0

package/src/compile.js

@@ -0,0 +1,230 @@
+import "./handlers/errorHandler.js"
+import fs from "fs"
+import path from "path"
+import { transform } from "./transform.js"
+
+import { readFile } from 'fs/promises';
+import { Debug } from "./external/core.js";
+import { stripComments } from "./parser.js";
+import { UseError } from "./external/classErrors.js";
+import { getDistPath, resolveSlimSource } from "./modulePaths.js";
+
+const compiled = new Set()
+
+let usePackages = true
+let jsdoc = false
+let declarations = false
+let check = true
+let useStyle = "import"
+
+function syncExternal() {
+    const srcExternal = path.resolve("src/external")
+    const distExternal = path.resolve("dist/external")
+
+    if (!fs.existsSync(srcExternal)) return
+
+    function syncDir(srcDir, distDir) {
+        fs.mkdirSync(distDir, { recursive: true })
+
+        for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+            const srcFull = path.join(srcDir, entry.name)
+            const distFull = path.join(distDir, entry.name)
+
+            if (entry.isDirectory()) {
+                syncDir(srcFull, distFull)
+                continue
+            }
+
+            if (fs.existsSync(distFull)) {
+                const srcMtime = fs.statSync(srcFull).mtimeMs
+                const distMtime = fs.statSync(distFull).mtimeMs
+                if (srcMtime <= distMtime) continue
+            }
+
+            fs.copyFileSync(srcFull, distFull)
+            Debug.log(`Synced: ${path.relative(".", distFull)}`)
+        }
+    }
+
+    syncDir(srcExternal, distExternal)
+}
+
+function extractUses(code) {
+    code = stripComments(code)
+    const uses = []
+
+    const patterns = [
+        /\buse\s+(@[\w$\/.-]+)\s*;?$/gm,
+        /\buse\s+(?:\{[^}]+\}|\*\s+as\s+[\w$]+|[\w$]+\s+as\s+[\w$]+|[\w$]+)\s+from\s+(@[\w$\/.-]+)\s*;?$/gm,
+        /\buse\s+(?:\{[^}]+\}|\*\s+as\s+[\w$]+|[\w$]+\s+as\s+[\w$]+|[\w$]+)\s+from\s+["']([^"']+)["']\s*;?$/gm,
+        /\buse\s+["']([^"']+)["']\s*;?$/gm,
+    ]
+
+    for (const pattern of patterns) {
+        let match
+        while ((match = pattern.exec(code)) !== null) {
+            const raw = match[1]
+            if (raw) uses.push(raw)
+        }
+    }
+
+    return [...new Set(uses)]
+}
+
+function compileFile(slimFile, isEntry = false, mainEntry = null) {
+    const hasSilmExtension = slimFile.endsWith(".slim")
+    const file = hasSilmExtension ? slimFile : slimFile + ".slim"
+    const abs = path.resolve(file)
+
+    if (compiled.has(abs)) return
+    compiled.add(abs)
+
+    if (!fs.existsSync(abs)) {
+        console.error(`\nError: File not found: ${abs}\n`)
+        process.exit(1)
+    }
+
+    const code = fs.readFileSync(abs, "utf8")
+
+    const uses = extractUses(code)
+
+    if (!usePackages && uses.length > 0) {
+        const err = new UseError(
+            `The "use" feature is disabled. Set "usePackages": true in slimconfig.json to enable imports (in ${abs}, found: use ${uses[0]})`
+        )
+        console.error(err)
+        process.exit(1)
+    }
+
+    for (const raw of uses) {
+        const depPath = resolveSlimSource(raw, abs)
+
+        if (depPath === null) continue
+
+        if (!fs.existsSync(depPath)) {
+            const err = new UseError(`No lib/file founded by the path: ${raw}`)
+            console.error(err)
+            process.exit(1)
+        }
+
+        if (depPath === abs) {
+            console.error(`\nError: Circular dependency detected in ${abs}\n`)
+            process.exit(1)
+        }
+        compileFile(depPath, false, mainEntry)
+    }
+
+    const { code: output, declarations: dts } = transform(code, abs, { jsdoc, declarations, check, uses: useStyle })
+
+    const outputPath = isEntry
+        ? path.resolve(`dist/${mainEntry}.js`)
+        : getDistPath(abs)
+
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+    fs.writeFileSync(outputPath, output)
+
+    if (dts) fs.writeFileSync(outputPath.replace(/\.js$/, ".d.ts"), dts)
+}
+
+function cleanDist(slimFileClear) {
+    const keep = new Set([
+        path.resolve(`dist/${slimFileClear}.js`),
+        path.resolve("dist/mappings.json"),
+    ])
+
+    function addDirToKeep(dir) {
+        if (!fs.existsSync(dir)) return
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.resolve(dir, entry.name)
+            keep.add(full)
+            if (entry.isDirectory()) addDirToKeep(full)
+        }
+    }
+    addDirToKeep(path.resolve("dist/external"))
+
+    for (const slimFile of compiled) {
+        if (slimFile === path.resolve(`${slimFileClear}.slim`)) {
+            keep.add(path.resolve(`dist/${slimFileClear}.js`))
+        } else {
+            keep.add(getDistPath(slimFile))
+        }
+    }
+
+    for (const kept of [...keep]) {
+        if (kept.endsWith(".js")) keep.add(kept.replace(/\.js$/, ".d.ts"))
+    }
+
+    function walkAndClean(dir) {
+        if (!fs.existsSync(dir)) return
+
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.resolve(dir, entry.name)
+
+            if (entry.isDirectory()) {
+                walkAndClean(full)
+
+                if (fs.readdirSync(full).length === 0) {
+                    fs.rmdirSync(full)
+                }
+            } else if (!keep.has(full)) {
+                fs.rmSync(full)
+                Debug.log(`Cleaned: ${path.relative(".", full)}`)
+            }
+        }
+    }
+
+    walkAndClean(path.resolve("dist"))
+}
+
+function writeJsConfig() {
+    const configPath = path.resolve("jsconfig.json")
+    if (fs.existsSync(configPath)) return
+
+    const config = {
+        compilerOptions: {
+            allowJs: true,
+            checkJs: false,
+            noEmit: true,
+            module: "esnext",
+            target: "es2020",
+            moduleResolution: "bundler",
+            strict: false,
+            skipLibCheck: true
+        },
+        include: ["dist"]
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 4) + "\n")
+    Debug.log("Created jsconfig.json for TypeScript checking")
+}
+
+async function main() {
+    let data
+
+    try {
+        const contents = await readFile("slimconfig.json", "utf8")
+        data = JSON.parse(contents)
+    } catch (error) {
+        console.error("Error reading or parsing slimconfig.json:", error)
+        process.exit(1)
+    }
+
+    usePackages = data.usePackages !== false
+    jsdoc = data.jsdoc === true
+    declarations = data.declarations === true
+    check = data.check !== false && process.env.SLIM_NO_CHECK !== "1"
+    useStyle = typeof data.uses === "string" ? data.uses : "import"
+
+    if (!("main" in data)) return
+
+    try {
+        syncExternal()
+        compileFile(data.main, true, data.main)
+        cleanDist(data.main)
+        if (jsdoc) writeJsConfig()
+    } catch (error) {
+        console.error(`\n${error.slimTypeErrors || error.slimSyntaxError ? error.message : error}\n`)
+        process.exit(1)
+    }
+}
+main()

package/src/external/classErrors.js

@@ -0,0 +1,202 @@
+// Source frames require a host-provided file reader.
+let readSource = null
+
+export function setSourceReader(reader) {
+    readSource = typeof reader === "function" ? reader : null
+}
+
+let __mappings__ = null
+let __sourceFile__ = null
+
+function loadMappings() {
+    if (__mappings__) return
+    try {
+        const data = JSON.parse(readSource(new URL("../../dist/mappings.json", import.meta.url)))
+        __mappings__ = data.mappings
+        __sourceFile__ = data.sourceFile
+    } catch {
+        __mappings__ = []
+    }
+}
+
+function resolveOriginalLine(generatedLine) {
+    loadMappings()
+    if (!__mappings__?.length) return { line: generatedLine, file: __sourceFile__ }
+
+    const mapping = __mappings__
+        .filter(m => m.generatedLine <= generatedLine)
+        .at(-1)
+
+    return {
+        line: mapping?.originalLine ?? generatedLine,
+        file: __sourceFile__
+    }
+}
+
+function isInternalFrame(normalized) {
+    return (
+        normalized.includes("node_modules") ||
+        normalized.includes("node:") ||
+        normalized.includes("/external/") ||
+        normalized.includes("/src/handlers/") ||
+        normalized.includes("/src/compile.js") ||
+        normalized.includes("/src/transform.js") ||
+        normalized.includes("/src/parser.js")
+    )
+}
+
+function parseStack(stack, skip = 0) {
+    if (!stack) return null
+
+    const frames = []
+    for (const line of stack.split("\n")) {
+        const match = line.match(/at .+ \((.+):(\d+):(\d+)\)/)
+            ?? line.match(/at (.+):(\d+):(\d+)/)
+
+        if (!match) continue
+
+        const [, file, ln, col] = match
+        const normalized = file.replace(/^file:\/\/\//, "").replace(/\\/g, "/")
+
+        if (isInternalFrame(normalized)) continue
+
+        frames.push({ file: normalized, line: parseInt(ln), col: parseInt(col) })
+    }
+
+    if (frames.length) {
+        const slimFrames = frames.filter(f => f.file.endsWith(".slim"))
+        const pool = slimFrames.length ? slimFrames : frames
+        return pool[Math.min(skip, pool.length - 1)]
+    }
+
+    for (const line of stack.split("\n")) {
+        const match = line.match(/at .+ \((.+dist\/output\.js):(\d+):(\d+)\)/)
+            ?? line.match(/at (.+dist\/output\.js):(\d+):(\d+)/)
+
+        if (!match) continue
+
+        const [, , ln, col] = match
+        const resolved = resolveOriginalLine(parseInt(ln))
+
+        return {
+            file: resolved.file,
+            line: resolved.line,
+            col: parseInt(col)
+        }
+    }
+
+    return null
+}
+
+function getSourceLine(file, line) {
+    if (!readSource) return null
+
+    try {
+        const content = readSource(file.replace(/\\/g, "/"))
+        return content?.split("\n")[line - 1]?.replace(/\r$/, "") ?? null
+    } catch {
+        return null
+    }
+}
+
+export function resolveErrorLocation(err) {
+    if (err?.file && err?.line) {
+        return {
+            file: err.file,
+            line: err.line,
+            col: err.col ?? null,
+            sourceLine: err.sourceLine ?? getSourceLine(err.file, err.line)
+        }
+    }
+
+    const loc = parseStack(err?.stack)
+    if (!loc) return null
+
+    return {
+        file: loc.file,
+        line: loc.line,
+        col: loc.col ?? null,
+        sourceLine: getSourceLine(loc.file, loc.line)
+    }
+}
+
+export function formatError(tag, message, file, line, col, sourceLine) {
+    const parts = [`\n${tag}: ${message}`]
+
+    if (file && line) {
+        parts.push(`    at ${file}:${line}:${col ?? 1}`)
+    }
+
+    if (sourceLine) {
+        const trimmed = sourceLine.trim()
+        const indent = sourceLine.search(/\S/)
+        const pointer = col
+            ? " ".repeat(Math.max(0, col - indent - 1)) + "^"
+            : "^"
+
+        parts.push(`\n  ${trimmed}`)
+        parts.push(`  ${pointer}`)
+    }
+
+    parts.push("")
+    return parts.join("\n")
+}
+
+export class LangError extends Error {
+    constructor(message, tag = "Error", meta = {}) {
+        super(message)
+        this.tag = tag
+        this.name = tag
+
+        const loc = parseStack(this.stack, meta.skipUserFrames ?? 0)
+
+        this.file = meta.file ?? loc?.file ?? null
+        this.line = meta.line ?? loc?.line ?? null
+        this.col = meta.col ?? loc?.col ?? null
+        this.sourceLine = meta.sourceLine ?? (
+            this.file && this.line
+                ? getSourceLine(this.file, this.line)
+                : null
+        )
+
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor)
+        }
+    }
+}
+
+export class StructError extends LangError {
+    constructor(m, meta) { super(m, "StructError", meta) }
+}
+export class StructPassedError extends LangError {
+    constructor(m, meta) { super(m, "StructPassedError", meta) }
+}
+export class StructExpectError extends LangError {
+    constructor(m, meta) { super(m, "StructExpectError", meta) }
+}
+export class StructResultError extends StructError {
+    constructor(m, meta) { super(m, "StructResultError", meta) }
+}
+
+export class TypeError_ extends LangError {
+    constructor(m, meta) { super(m, "TypeError", meta) }
+}
+export class RuntimeError extends LangError {
+    constructor(m, meta) { super(m, "RuntimeError", meta) }
+}
+
+export class ArgumentDeclarationTypeError extends TypeError_ {
+    constructor(m, meta) { super(m, meta) }
+}
+
+export class EnumError extends LangError {
+    constructor(m, meta) { super(m, "EnumError", meta) }
+}
+
+export class UseError extends Error {
+    constructor(m, meta) { super(m, "UseError", meta) }
+}
+
+export class TypeDefError extends TypeError {
+    constructor(m, meta) { super(m, "TypeDefError", meta) }
+}

package/src/external/client.js

@@ -0,0 +1,38 @@
+// Browser-safe runtime subset serialized into client handlers.
+
+export function log(...args) { console.log(...args) }
+export function warn(...args) { console.warn(...args) }
+export function error(...args) { console.error(...args) }
+export function info(...args) { console.info(...args) }
+export function debug(...args) { console.log(...args) }
+
+export function type(obj) {
+	if (obj === null) return "null"
+	if (obj === undefined) return "undefined"
+	if (typeof obj === "number" && Number.isNaN(obj)) return "NaN"
+
+	if (typeof HTMLElement !== "undefined" && obj instanceof HTMLElement) return "element"
+	if (obj && typeof obj === "object" && obj.nodeType === 11) return "fragment"
+
+	if (typeof obj === "function" && obj.__type__ === true) return "type"
+	if (typeof obj === "function" && obj.__component__ === true) return "component"
+
+	if (Array.isArray(obj)) {
+		if (obj.length > 0) {
+			const first = type(obj[0])
+			if (obj.every(el => type(el) === first)) return first + "[]"
+		}
+		return "array"
+	}
+
+	if (typeof obj === "object") return "object"
+	if (typeof obj === "string") return "string"
+	if (typeof obj === "number") return Number.isInteger(obj) ? "int" : "float"
+	if (typeof obj === "boolean") return "bool"
+	if (typeof obj === "function") return /^\s*class\s+/.test(obj.toString()) ? "class" : "function"
+
+	return undefined
+}
+
+// Client declarations are emitted before the handler table.
+export const CLIENT_RUNTIME = [log, warn, error, info, debug, type]