@slim-lang/core 1.2.0

package/packages/slim/.spm

@@ -0,0 +1,7 @@
+name = "slim"
+description = "Slim Standart Library"
+version = "1.0.0"
+
+@ github
+	organization = "true"
+	repo = "spm-libs/std"

package/packages/slim/converters/main.slim

@@ -0,0 +1,106 @@
+use { SymbolInstance, AnyArray } from @slim/types/common
+use { TimeStamp } from @slim/types/time
+use { JSONString } from @slim/types/formats
+
+export func int(value: string | int): int {
+    if (kindof value == "int") return value
+
+    const result = Number(value)
+
+    if (!Number.isInteger(result)) {
+        throw new TypeError(`Cannot convert "${value}" to int`)
+    }
+
+    return result
+}
+
+export func float(value: string | float | int): number {
+    if (type(value) == "float") return value
+
+    const result = Number(value)
+
+    if (Number.isNaN(result)) {
+        throw new TypeError(`Cannot convert "${value}" to float`)
+    }
+
+    return result
+}
+
+export func number(value: string | float | int): number {
+    if (typeof value == "number") return value
+
+    const result = Number(value)
+
+    if (Number.isNaN(result)) {
+        throw new TypeError(`Cannot convert "${value}" to number`)
+    }
+
+    return result
+}
+
+export func string(value: any): string {
+    return String(value)
+}
+
+export func bool(value: int | float | string | bool): bool {
+    if (typeof value == "boolean") return value
+
+    if (typeof value == "number") {
+        return value != 0
+    }
+
+    if (typeof value == "string") {
+        const str = value.trim().toLowerCase()
+
+        if (str == "true" || str == "1") return true
+        if (str == "false" || str == "0") return false
+    }
+
+    return Boolean(value)
+}
+
+export func bigint(value: number): number {
+    try {
+        return BigInt(value)
+    }
+    catch {
+        throw new TypeError(`Cannot convert "${value}" to bigint`)
+    }
+}
+
+export func symbol(value: any): SymbolInstance {
+    return Symbol(String(value))
+}
+
+export func array(value: any): AnyArray {
+    if (Array.isArray(value)) return value
+
+    return [value]
+}
+
+export func date(value: TimeStamp): any {
+    const result = new Date(value)
+
+    if (Number.isNaN(result.getTime())) {
+        throw new TypeError(`Cannot convert "${value}" to date`)
+    }
+
+    return result
+}
+
+export func json(value: AnyArray | string | number | object): object {
+    if (typeof value == "string") {
+        try {
+            return JSON.parse(value)
+        }
+        catch {
+            throw new TypeError("Invalid JSON")
+        }
+    }
+
+    return JSON.parse(JSON.stringify(value))
+}
+
+export func jsonstr(value: AnyArray | string | number | object): JSONString {
+    return JSON.stringify(value)
+}

package/packages/slim/helpers/array.slim

@@ -0,0 +1,25 @@
+use { AnyArray } from @slim/types/common
+
+const oldSort = Array.prototype.sort;
+
+Array.prototype.sort = function (compareFn) {
+    if (compareFn) return oldSort.call(this, compareFn);
+
+    if (this.every(v => typeof v === "number")) {
+        return oldSort.call(this, (a, b) => a - b);
+    }
+
+    return oldSort.call(this);
+};
+
+func range(min: int, max: int): AnyArray {
+    const res = []
+    for (let i = min; i <= max; i++) {
+        res.push(i)
+    }
+    return res
+}
+
+export {
+    range
+}

package/packages/slim/helpers/path.slim

@@ -0,0 +1,3 @@
+export func replaceBackslashes(path: string) {
+    return path.replaceAll('\\', '/')
+}

package/packages/slim/helpers/request.slim

@@ -0,0 +1,102 @@
+export class RequestHelper {
+    constructor(options: object = {}) {
+        this.baseURL = options.baseURL || ""
+        this.headers = options.headers || {}
+        this.timeout = options.timeout || 10000
+    }
+
+    async request(url, options = {}) {
+        const controller = new AbortController()
+
+        const timeout = setTimeout(() => {
+            controller.abort()
+        }, this.timeout)
+
+        try {
+            const response = await fetch(this.baseURL + url, {
+                ...options,
+                headers: {
+                    ...this.headers,
+                    ...options.headers
+                },
+                signal: controller.signal
+            })
+
+            clearTimeout(timeout)
+
+            const type = response.headers.get("content-type") || ""
+
+            let data
+
+            if (type.includes("application/json")) {
+                data = await response.json()
+            } else if (type.includes("text/")) {
+                data = await response.text()
+            } else {
+                data = await response.blob()
+            }
+
+            if (!response.ok) {
+                throw {
+                    status: response.status,
+                    statusText: response.statusText,
+                    data
+                }
+            }
+
+            return data
+        } finally {
+            clearTimeout(timeout)
+        }
+    }
+
+    get(url, options = {}) {
+        return this.request(url, {
+            ...options,
+            method: "GET"
+        })
+    }
+
+    post(url, body, options = {}) {
+        return this.request(url, {
+            ...options,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...options.headers
+            },
+            body: JSON.stringify(body)
+        })
+    }
+
+    put(url, body, options = {}) {
+        return this.request(url, {
+            ...options,
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                ...options.headers
+            },
+            body: JSON.stringify(body)
+        })
+    }
+
+    patch(url, body, options = {}) {
+        return this.request(url, {
+            ...options,
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...options.headers
+            },
+            body: JSON.stringify(body)
+        })
+    }
+
+    delete(url, options = {}) {
+        return this.request(url, {
+            ...options,
+            method: "DELETE"
+        })
+    }
+}

package/packages/slim/helpers/string.slim

@@ -0,0 +1,27 @@
+use * as crypto from "node:crypto"
+use { SHA256, QuickHash } from @slim/types/hash
+
+export default const StringHelper: object = {
+    len(str: string): int {
+        if(kindof str == "string") return str.length
+    },
+    truncate(str: string, maxLength: int): string {
+        if (str.length > maxLength) {
+            return str.slice(0, maxLength) + '...';
+        }
+        return str;
+    },
+    hash(str: string): SHA256 {
+        return crypto.createHash("sha256").update(str).digest("hex")
+    },
+    quickHash(str: string): QuickHash {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            hash = (hash << 5) - hash + str.charCodeAt(i);
+            hash |= 0;
+        }
+        return hash;
+    }
+}
+
+lock StringHelper;

package/packages/slim/main.slim

@@ -0,0 +1,42 @@
+use { readFile } from 'fs/promises';
+use { join } from 'path';
+
+use { SemVer } from @slim/types/formats
+
+export struct Slim {
+    version?: SemVer | undefined = undefined
+    rootDir?: string = undefined
+    workDir?: string = undefined
+}
+export struct SlimConfig {
+    workDir: string | undefined = undefined
+}
+
+export async func getPackageData(): object {
+    try {
+        const filePath = join(process.cwd(), 'package.json'); 
+        const fileContent = await readFile(filePath, 'utf-8');
+        
+        const packageData = JSON.parse(fileContent);
+        return Slim.new({ version: packageData.version, rootDir: process.cwd(), workDir: packageData.main })
+    } catch (error) {
+        return Slim.new({})
+    }
+}
+
+export async func getConfigData(): object {
+    try {
+        const filePath = join(process.cwd(), 'slimconfig.json'); 
+        const fileContent = await readFile(filePath, 'utf-8');
+        
+        const packageData = JSON.parse(fileContent);
+        return SlimConfig.new({ workDir: packageData.main })
+    } catch (error) {
+        return SlimConfig.new({})
+    }
+}
+
+export async func getVersion(): SemVer {
+    const pkg = await getPackageData()
+    return pkg.version
+}

package/packages/slim/parse/main.slim

@@ -0,0 +1,25 @@
+use fs from "node:fs/promises"
+use path from "node:path"
+
+export class ReadError extends Error {}
+
+export async func parseJSON(fpath: string): object {
+    try {
+        const filePath: string = path.join(fpath); 
+        const data: string = await fs.readFile(filePath, 'utf8');
+
+        return JSON.parse(data)
+    } catch (err) {
+        throw new ReadError(err)
+    }
+}
+export async func parseText(fpath: string): string {
+    try {
+        const filePath: string = path.join(fpath); 
+        const data: string = await fs.readFile(filePath, 'utf8');
+
+        return data
+    } catch (err) {
+        throw new ReadError(err)
+    }
+}