@slim-lang/core 1.2.2 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@slim-lang/core",
-	"version": "1.2.2",
+	"version": "1.2.4",
 	"description": "Slim extends JavaScript with runtime types, structs, operators, and components, compiling to plain Javascript",
 	"main": "index.js",
 	"type": "module",

package/src/bin/config.default.json

@@ -1,5 +1,6 @@
 {
     "main": "path/to/your/files",
     "usePackages": true,
-    "uses": "import"
+    "uses": "import",
+    "packages": "packages"
 }

package/src/bin/helpers.js

@@ -2,6 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { rm, mkdir } from 'node:fs/promises';
 import chalk from "chalk";
+import { projectPackagesDir } from "../modulePaths.js";
+
+export { projectPackagesDir };
 
 export const formatError = chalk.red.bold
 export const formatSuccess = chalk.green.bold
@@ -30,10 +33,10 @@ export function error(...text) {
 }
 
 export function isPackageExists(name) {
-	return fs.existsSync(path.join(rootPath, "packages", name))
+	return fs.existsSync(path.join(projectPackagesDir(), name))
 }
 export function getPackagePath(name) {
-	return path.join(rootPath, "packages", name)
+	return path.join(projectPackagesDir(), name)
 }
 
 export async function deleteDirectory(dirPath) {

package/src/bin/spm.js

@@ -1,9 +1,9 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Command } from "commander";
 import { formatError, formatBold, formatItalic, formatSuccess, createFolder, createFile } from "./helpers.js"
 import pkg from "../../package.json" with { type: "json" };
-import { log, isPackageExists, rootPath, deleteDirectory, loading, delay } from "./helpers.js";
+import { log, isPackageExists, rootPath, deleteDirectory, loading, delay, projectPackagesDir } from "./helpers.js";
 
 import fs from "node:fs"
 import path from "node:path"
@@ -27,7 +27,7 @@ function errlog(...args) {
 	console.log(formatError(...args))
 }
 
-const packagesPath = path.join(rootPath, "packages")
+const packagesPath = projectPackagesDir()
 
 function renderObject(obj, indent = 0) {
     let output = "";
@@ -73,7 +73,7 @@ spm
 spm
     .command("list")
 	.action(() => {
-		const targetDir = path.join(rootPath, "packages")
+		const targetDir = packagesPath
 		if (!fs.existsSync(targetDir)) {
 			spmlog("No packages installed (the packages/ directory does not exist)")
 			return
@@ -186,7 +186,7 @@ spm
 					}
 				}
 
-				const res = await deleteDirectory(path.join(rootPath, "packages", name))
+				const res = await deleteDirectory(path.join(packagesPath, name))
 
 				if (res) {
 					removeLockEntry(name)
@@ -257,7 +257,7 @@ spm
 			await loading({
 				startMsg: `Creating path for ${name}`,
 				callback: async ({ fail, ok }) => {
-					const packagePath = path.join(rootPath, "packages", name)
+					const packagePath = path.join(packagesPath, name)
 
 					if (isExists) return fail("Package is already exists")
 					else {
@@ -336,7 +336,7 @@ spm
 			const githubRepo = SPMContent.github.repo
 			const version = SPMContent.version
 			const description = SPMContent.description
-			const packagePath = path.join("packages", name)
+			const packagePath = path.join(packagesPath, name)
 
 			if ("github" in SPMContent && "repo" in SPMContent.github) {
 				await loading({
@@ -445,7 +445,7 @@ spm
 				spmlog(formatError("No GitHub repository specified"));
 			}
 		} else {
-			spmlog(formatError(`No package founded: /packages/${name}`));
+			spmlog(formatError(`No package founded: ${path.relative(process.cwd(), path.join(packagesPath, name)) || name}`));
 		}
 	});
 

package/src/checker.js

@@ -5,8 +5,6 @@ import { computeLineStarts, offsetToLineCol } from "./sourcemap.js"
 
 const traverse = _traverse.default ?? _traverse
 
-// Check annotations before lowering; report only definite type conflicts.
-
 const NUMERIC = new Set(["int", "float", "number"])
 const KNOWN = new Set([
     "int", "float", "number", "string", "bool", "null", "undefined",
@@ -87,7 +85,6 @@ function normalize(label) {
     return trimmed
 }
 
-// Resolve inherited fields so structs can cross module boundaries.
 function resolveStruct(name, env, seen = new Set()) {
     const definition = env.structs.get(name)
     if (!definition) return null
@@ -135,7 +132,6 @@ export function createEnvironment() {
     }
 }
 
-// Module declarations keyed by absolute source path.
 const moduleTypes = new Map()
 
 function signatureFor(name, path_, env) {
@@ -149,7 +145,7 @@ const BUILTIN_CLASSES = new Set(["Map", "Set", "Date", "Promise", "RegExp", "Err
 function isOpen(label, env) {
     const base = baseName(label)
     if (!base) return true
-    // Custom validators shadow built-ins and cannot be evaluated statically.
+
     if (env.customTypes.has(base)) return true
     if (KNOWN.has(base) || BUILTIN_CLASSES.has(base)) return false
     if (env.structs.has(base) || env.enums.has(base)) return false
@@ -217,7 +213,6 @@ function acceptsAtom(target, source, env) {
     return false
 }
 
-// A union needs one compatible arm; array literals need every element to fit.
 export function accepts(target, source, env, requireAll = false) {
     if (!target || !source) return true
 
@@ -598,7 +593,6 @@ function checkStructLiteral(structName, node, path_, env, report) {
     }
 }
 
-// Inspect lowered match expressions to preserve exhaustiveness checks.
 function matchExpression(node) {
     if (!t.isCallExpression(node) || node.arguments.length !== 1) return null
 
@@ -839,7 +833,6 @@ function buildModuleTypes(ast, env) {
     return record
 }
 
-// Import known declarations; unresolved modules remain unchecked.
 function seedImports(env, imports, wildcards) {
     const merge = (record, name, local) => {
         if (record.structs.has(name)) env.structs.set(local, record.structs.get(name))
@@ -850,7 +843,6 @@ function seedImports(env, imports, wildcards) {
 
     const sources = new Set([...wildcards, ...imports.map(entry => entry.source)])
 
-    // Local declarations override explicit and transitive imports.
     for (const source of sources) {
         const record = moduleTypes.get(source)
         if (!record) continue

package/src/compile.js

@@ -18,8 +18,6 @@ let check = true
 let useStyle = "import"
 
 function syncExternal() {
-    // The runtime ships inside the package; the compiled output goes to the
-    // project's own dist/ (so this works both locally and when installed).
     const srcExternal = path.join(PACKAGE_ROOT, "src/external")
     const distExternal = path.resolve("dist/external")
 

package/src/modulePaths.js

@@ -5,16 +5,24 @@ import { fileURLToPath } from "node:url"
 
 const slimExtension = ".slim"
 
-// Root of the installed toolchain package (…/src/modulePaths.js -> package root).
-// Locally this equals the project root; when installed it points into
-// node_modules/@slim-lang/core, where the shipped stdlib (@slim/*) lives.
 export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 
-// `@`-imports resolve against the project's own packages/ (spm installs) first,
-// then the stdlib shipped inside the package. When run locally the two are the
-// same directory.
+let projectPackagesCache = null
+export function projectPackagesDir() {
+    if (projectPackagesCache) return projectPackagesCache
+
+    let dir = "packages"
+    try {
+        const config = JSON.parse(fs.readFileSync(path.join(process.cwd(), "slimconfig.json"), "utf8"))
+        if (typeof config.packages === "string" && config.packages.trim()) dir = config.packages
+    } catch {}
+
+    projectPackagesCache = path.resolve(dir)
+    return projectPackagesCache
+}
+
 function packageRoots() {
-    const projectPackages = path.resolve("packages")
+    const projectPackages = projectPackagesDir()
     const shippedPackages = path.join(PACKAGE_ROOT, "packages")
 
     return projectPackages === shippedPackages
@@ -41,16 +49,28 @@ 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)
+    const shippedPackages = path.join(PACKAGE_ROOT, "packages")
+    const projectPackages = projectPackagesDir()
+
+    let relative
+
+    if (isWithin(shippedPackages, abs)) {
+        relative = path.join("packages", path.relative(shippedPackages, abs))
+    } else if (isWithin(projectPackages, abs)) {
+        relative = path.join(path.basename(projectPackages), path.relative(projectPackages, abs))
+    } else if (isWithin(srcRoot, abs)) {
+        relative = path.relative(srcRoot, abs)
+    } else if (isWithin(projectRoot, abs)) {
+        relative = path.relative(projectRoot, abs)
+    } else {
+        const stripped = path.relative(projectRoot, abs).split(path.sep).filter(seg => seg !== "..")
+        relative = stripped.length ? path.join(...stripped) : path.basename(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("@")) {
@@ -67,8 +87,6 @@ export function resolveSlimSource(raw, fromFile) {
 
         if (isNodeModule(raw)) return null
 
-        // Not found in any root: return the project-local path so errors point
-        // at the user's own packages/ directory.
         return path.join(roots[0], packageName + slimExtension)
     }
 

package/src/parser.js

@@ -43,7 +43,6 @@ function wordOperatorEdits(code) {
     for (const token of tokenize(code)) {
         if (token.type === "ws" || token.type === "newline" || token.type === "comment") continue
 
-        // Lower word operators only after an operand.
         const replacement = token.type === "name" ? replacements[token.value] : undefined
         if (replacement && endsExpression(prev)) {
             edits.push({ start: token.start, end: token.end, replacement })
@@ -290,7 +289,6 @@ function functionEdits(text) {
     })
 }
 
-// Cache tokens for whole-file and extracted-body scans.
 const tokenCache = new Map()
 
 function tokensFor(src) {
@@ -309,7 +307,6 @@ function tokensFor(src) {
     return entry
 }
 
-// Match brackets by tokens so literals and comments do not affect depth.
 function readBalanced(src, pos, open = "{", close = "}") {
     const { tokens, starts } = tokensFor(src)
     let index = starts.get(pos)
@@ -329,8 +326,6 @@ function readBalanced(src, pos, open = "{", close = "}") {
     return -1
 }
 
-// Read balanced arguments after matching a construct head.
-// Return type may be introduced by `->` or `:` (e.g. `func f(): number`).
 const returnArrow = /\s*(?:->|:)\s*/y
 
 function headMatcher(head, tail) {
@@ -462,7 +457,6 @@ function topLevelWhen(str) {
     return -1
 }
 
-// Recursively lower nested match expressions without touching strings.
 function lowerMatches(str) {
     if (!str.includes("match")) return str
 
@@ -627,8 +621,6 @@ function structuralEdits(text) {
                     let rest = line.slice(idx + 1).trim()
                     if (!field) continue
 
-                    // Optional fields may be written as `*key` or `key?`; normalize
-                    // both to the `*key` form the struct runtime understands.
                     let optional = false
                     if (field.startsWith("*")) { optional = true; field = field.slice(1).trim() }
                     if (field.endsWith("?")) { optional = true; field = field.slice(0, -1).trim() }
@@ -688,8 +680,6 @@ function structuralEdits(text) {
                 const head = declarationHead.exec(src)
                 if (!head) return null
 
-                // `export default const X: T = ...` is not valid JS as a single
-                // statement; lower it to a typed declaration plus `export default X`.
                 const leadingDefault = src.slice(0, i).match(/export\s+default\s+$/)
                 const start = leadingDefault ? i - leadingDefault[0].length : i
 
@@ -708,10 +698,6 @@ function structuralEdits(text) {
             },
             ({ keyword, name, type, expr, exprStart, defaultExport }) => {
                 const pattern = name.startsWith("{") || name.startsWith("[")
-                // Keep the declaration exported so the module wrapper leaves it at
-                // top level, then re-export the binding as default. Emitting a bare
-                // `const` plus `export default X` would trap the `const` in the
-                // module's try/catch, leaving the default export undefined.
                 const prefix = defaultExport ? "export " : ""
                 const head = pattern
                     ? `${prefix}${keyword} ${name} = __typed_pattern__(`
@@ -730,7 +716,6 @@ function structuralEdits(text) {
             /(\w[\w$.]*(?:\[.*?\])?)\s*(?:=>\s*([\w$]+))?\s*\n((?:\s*\|(?!\|)[^\n]+\n?)+)/g,
             (match, source, alias, pipes) => {
                 const steps = [...pipes.matchAll(/\|\s*([\w$]+)\(([^)]*)\)/g)]
-                // Preserve non-pipe bars, such as multiline union types.
                 if (steps.length === 0) return match
 
                 const callbackMethods = new Set([

package/src/transform.js

@@ -28,9 +28,6 @@ function getTypeReferenceName(typeText) {
     return withoutGeneric.split("::")[0]
 }
 
-// Builtin type names are always matched by label; they must never be resolved
-// through a same-named binding in scope (e.g. a `const string` variable would
-// otherwise shadow the primitive `string` type).
 const BUILTIN_TYPE_NAMES = new Set([
     "int", "float", "number", "string", "bool", "null", "undefined",
     "object", "array", "function", "any", "element"
@@ -439,7 +436,6 @@ function getRuntimePath(sourceFile, entry) {
     return relFixed.startsWith(".") ? relFixed : "./" + relFixed
 }
 
-// DOM globals select the full runtime; pure code uses the portable core.
 const DOM_RUNTIME = new Set([
     "htmlToVdom", "HTMLElement", "__html__",
     "__flush_events__", "__bind_events__", "__lifecycle__",
@@ -460,13 +456,6 @@ function usesDom(ast) {
     return found
 }
 
-// `use` mirrors `import`: `use { X } from Y` is a named import, `use * as X`
-// a namespace import, and a bare `use X from Y` a default import — exactly like
-// `import X from Y`. Named exports (including Slim's `export const`/`export func`)
-// must therefore be brought in with braces: `use { X } from Y`.
-//
-// When `bareIsDefault` is false (the legacy `"uses": "named"` config style), a
-// bare `use X from Y` instead lowers to a named import `import { X } from Y`.
 function parseSpecifiers(name, bareIsDefault = true) {
     const trimmed = name.trim()
 
@@ -485,7 +474,6 @@ function parseSpecifiers(name, bareIsDefault = true) {
         })
     }
 
-    // `use X as Y from Z` renames a named export (there is no `import X as Y`).
     const aliasMatch = trimmed.match(/^([\w$]+)\s+as\s+([\w$]+)$/)
     if (aliasMatch) {
         return [t.importSpecifier(t.identifier(aliasMatch[2]), t.identifier(aliasMatch[1]))]
@@ -530,8 +518,6 @@ function formatSyntaxError(err, originalCode, sourceFile, mapped) {
 }
 
 export function transform(code, sourceFile = "input.ps", options = {}) {
-    // `"uses": "named"` (or "legacy") restores the old bare-import style where a
-    // bare `use X from Y` is a named import; the default mirrors `import`.
     const bareIsDefault = options.uses !== "named" && options.uses !== "legacy"
     const asyncFunctions = new Set()
     const imports = new Map()
@@ -601,7 +587,6 @@ export function transform(code, sourceFile = "input.ps", options = {}) {
         }
     })
 
-    // Check annotations before lowering or writing output.
     if (options.check !== false) {
         const moduleImports = []
         const moduleWildcards = []