@axium/core 0.9.0 → 0.10.0

package/dist/access.d.ts

@@ -6,13 +6,27 @@ export interface AccessControl {
     createdAt: Date;
     permission: Permission;
 }
-export declare enum Permission {
-    None = 0,
-    Read = 1,
-    Comment = 2,
-    Edit = 3,
-    Manage = 5
-}
+declare const _Permission: {
+    readonly None: 0;
+    readonly Read: 1;
+    readonly Comment: 2;
+    readonly Edit: 3;
+    readonly Manage: 5;
+};
+export declare const Permission: import("zod").ZodEnum<{
+    readonly None: 0;
+    readonly Read: 1;
+    readonly Comment: 2;
+    readonly Edit: 3;
+    readonly Manage: 5;
+}> & {
+    readonly None: 0;
+    readonly Read: 1;
+    readonly Comment: 2;
+    readonly Edit: 3;
+    readonly Manage: 5;
+};
+export type Permission = (typeof _Permission)[keyof typeof _Permission];
 export declare const permissionNames: {
     0: string;
     1: string;
@@ -26,3 +40,4 @@ export interface AccessControllable {
     acl?: AccessControl[];
 }
 export declare function hasPermission(item: AccessControllable, userId: string | undefined, permission: Permission): boolean;
+export {};

package/dist/access.js

@@ -1,11 +1,12 @@
-export var Permission;
-(function (Permission) {
-    Permission[Permission["None"] = 0] = "None";
-    Permission[Permission["Read"] = 1] = "Read";
-    Permission[Permission["Comment"] = 2] = "Comment";
-    Permission[Permission["Edit"] = 3] = "Edit";
-    Permission[Permission["Manage"] = 5] = "Manage";
-})(Permission || (Permission = {}));
+import { enum as zEnum } from 'zod';
+const _Permission = {
+    None: 0,
+    Read: 1,
+    Comment: 2,
+    Edit: 3,
+    Manage: 5,
+};
+export const Permission = Object.assign(zEnum(_Permission), _Permission);
 export const permissionNames = {
     [Permission.None]: 'No Permissions',
     [Permission.Read]: 'Reader',

package/dist/io.d.ts

@@ -15,7 +15,7 @@ export interface ProgressIO {
     progress(value: number, max: number, message?: any): void;
     done(): void;
 }
-export declare function useProgressIO(io: ProgressIO): void;
+export declare function useProgress(io: ProgressIO): void;
 export declare let debug: (...args: any[]) => void;
 export declare let log: (...args: any[]) => void;
 export declare let info: (...args: any[]) => void;

package/dist/io.js

@@ -18,7 +18,7 @@ export function _setDebugOutput(enabled) {
 export let start;
 export let progress;
 export let done;
-export function useProgressIO(io) {
+export function useProgress(io) {
     start = io.start.bind(io);
     progress = io.progress.bind(io);
     done = io.done.bind(io);

package/dist/node/io.d.ts

@@ -1,3 +1,4 @@
+import * as z from 'zod';
 export * from '../io.js';
 export declare function setCommandTimeout(value: number): void;
 /**
@@ -7,5 +8,10 @@ export declare function setCommandTimeout(value: number): void;
 export declare function run(message: string, command: string): Promise<string>;
 /** Yet another convenience function */
 export declare function exit(message: string | Error, code?: number): never;
-export declare function handleError(e: number | string | Error): void;
+export declare function handleError(e: number | string | Error): never;
+/**
+ *
+ * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.
+ */
+export declare function readJSON<S extends z.ZodType>(path: string, schema: S): z.infer<S>;
 export declare function writeJSON(path: string, data: any): void;

package/dist/node/io.js

@@ -1,37 +1,174 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { exec } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
+import { writeFileSync, readFileSync } from 'node:fs';
 import { styleText } from 'node:util';
-import { _debugOutput, done, error, start, useOutput, useProgressIO } from '../io.js';
+import * as io from '../io.js';
+import * as z from 'zod';
 export * from '../io.js';
-useProgressIO({
+let _currentOperation = null, _progress = null;
+function handleProgress() {
+    if (!_currentOperation || !_progress)
+        return {
+            [Symbol.dispose]() {
+                if (!_progress)
+                    _currentOperation = null;
+            },
+        };
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    return {
+        [Symbol.dispose]() {
+            process.stdout.write(_currentOperation + '... ');
+            if (_progress)
+                io.progress(..._progress);
+        },
+    };
+}
+io.useProgress({
     start(message) {
-        process.stdout.write(message + '... \x1b[s');
+        _currentOperation = message;
+        process.stdout.write(message + '... ');
     },
     /** @todo implement additional messaging */
     progress(value, max, message) {
-        process.stdout.write(`\x1b[u\x1b[K${value.toString().padStart(max.toString().length)}/${max}`);
-        if (value >= max)
+        _progress = [value, max];
+        value++;
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(`${_currentOperation}... ${value.toString().padStart(max.toString().length)}/${max} ${message && value < max ? `(${message})` : ''}`);
+        if (value >= max) {
+            _currentOperation = null;
             console.log();
+        }
     },
     done() {
+        _currentOperation = null;
         console.log('done.');
     },
 });
-useOutput({
+io.useOutput({
     error(message) {
-        console.error(message.startsWith('\x1b') ? message : styleText('red', message));
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_1, handleProgress(), false);
+            console.error(message.startsWith('\x1b') ? message : styleText('red', message));
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
     },
     warn(message) {
-        console.warn(message.startsWith('\x1b') ? message : styleText('yellow', message));
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_2, handleProgress(), false);
+            console.warn(message.startsWith('\x1b') ? message : styleText('yellow', message));
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
     },
     info(message) {
-        console.info(message.startsWith('\x1b') ? message : styleText('blue', message));
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_3, handleProgress(), false);
+            console.info(message.startsWith('\x1b') ? message : styleText('blue', message));
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
     },
     log(message) {
-        console.log(message);
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_4, handleProgress(), false);
+            console.log(message);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
     },
     debug(message) {
-        _debugOutput && console.debug(message.startsWith('\x1b') ? message : styleText('gray', message));
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!io._debugOutput)
+                return;
+            const _ = __addDisposableResource(env_5, handleProgress(), false);
+            console.debug(message.startsWith('\x1b') ? message : styleText('gray', message));
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
     },
 });
 let timeout = 1000;
@@ -45,7 +182,7 @@ export function setCommandTimeout(value) {
 export async function run(message, command) {
     let stderr;
     try {
-        start(message);
+        io.start(message);
         const { promise, resolve, reject } = Promise.withResolvers();
         exec(command, { timeout }, (err, stdout, _stderr) => {
             stderr = _stderr.startsWith('ERROR:') ? _stderr.slice(6).trim() : _stderr;
@@ -55,7 +192,7 @@ export async function run(message, command) {
                 resolve(stdout);
         });
         const value = await promise;
-        done();
+        io.done();
         return value;
     }
     catch (error) {
@@ -70,7 +207,7 @@ export async function run(message, command) {
 export function exit(message, code = 1) {
     if (message instanceof Error)
         message = message.message;
-    error(message);
+    io.error(message);
     process.exit(code);
 }
 export function handleError(e) {
@@ -79,6 +216,19 @@ export function handleError(e) {
     else
         exit(e);
 }
+/**
+ *
+ * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.
+ */
+export function readJSON(path, schema) {
+    try {
+        const data = JSON.parse(readFileSync(path, 'utf-8'));
+        return schema.parse(data);
+    }
+    catch (e) {
+        throw e instanceof z.core.$ZodError ? z.prettifyError(e) : e instanceof Error ? e.message : e;
+    }
+}
 export function writeJSON(path, data) {
     writeFileSync(path, JSON.stringify(data, null, 4).replaceAll(/^( {4})+/g, match => '\t'.repeat(match.length / 4)), 'utf-8');
 }

package/dist/user.d.ts

@@ -20,8 +20,18 @@ export interface UserInternal extends User {
     tags: string[];
 }
 export declare const userPublicFields: ["id", "image", "name", "registeredAt", "roles"];
-type UserPublicField = (typeof userPublicFields)[number];
-export interface UserPublic extends Pick<User, UserPublicField> {
+export declare const UserPublic: z.ZodObject<{
+    id: z.ZodUUID;
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    emailVerified: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodDate>>>;
+    image: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    roles: z.ZodArray<z.ZodString>;
+    registeredAt: z.ZodCoercedDate<unknown>;
+    isAdmin: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface UserPublic extends z.infer<typeof UserPublic> {
 }
 export declare const userProtectedFields: ["email", "emailVerified", "preferences", "isAdmin"];
 export declare const UserChangeable: z.ZodObject<{
@@ -70,4 +80,3 @@ export declare const LogoutSessions: z.ZodObject<{
     id: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
     confirm_all: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-export {};

package/dist/user.js

@@ -13,6 +13,9 @@ export const User = z.object({
     isAdmin: z.boolean(),
 });
 export const userPublicFields = ['id', 'image', 'name', 'registeredAt', 'roles'];
+export const UserPublic = User.partial(Object.fromEntries(Object.keys(User.shape)
+    .filter((key) => !userPublicFields.includes(key))
+    .map(key => [key, true])));
 export const userProtectedFields = ['email', 'emailVerified', 'preferences', 'isAdmin'];
 export const UserChangeable = User.pick({
     name: true,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/core",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"funding": {
 		"type": "individual",