@axium/core 0.5.5 → 0.6.0

package/dist/api.d.ts

@@ -39,7 +39,7 @@ export interface AppMetadata {
  * Types for all API endpoints
  * @internal
  */
-export interface _apiTypes {
+export interface $API {
     metadata: {
         GET: {
             version: string;
@@ -118,8 +118,8 @@ export interface _apiTypes {
         }, AccessControl];
     };
 }
-export type Endpoint = keyof _apiTypes;
-export type APIFunction<Method extends RequestMethod, E extends Endpoint> = Method extends keyof _apiTypes[E] ? _apiTypes[E][Method] extends [infer Body, infer Result] ? (body: Body) => Promise<Result> : () => _apiTypes[E][Method] : unknown;
-export type RequestBody<Method extends RequestMethod, E extends Endpoint> = Method extends keyof _apiTypes[E] ? _apiTypes[E][Method] extends [infer Body, unknown] ? Body : any : unknown;
-export type Result<Method extends RequestMethod, E extends Endpoint> = Promise<Method extends keyof _apiTypes[E] ? (_apiTypes[E][Method] extends [unknown, infer R] ? R : _apiTypes[E][Method]) : unknown>;
+export type Endpoint = keyof $API;
+export type APIFunction<Method extends RequestMethod, E extends Endpoint> = Method extends keyof $API[E] ? $API[E][Method] extends [infer Body, infer Result] ? (body: Body) => Promise<Result> : () => $API[E][Method] : unknown;
+export type RequestBody<Method extends RequestMethod, E extends Endpoint> = Method extends keyof $API[E] ? $API[E][Method] extends [infer Body, unknown] ? Body : any : unknown;
+export type Result<Method extends RequestMethod, E extends Endpoint> = Promise<Method extends keyof $API[E] ? ($API[E][Method] extends [unknown, infer R] ? R : $API[E][Method]) : unknown>;
 export type APIParameters<S extends string> = S extends `${string}/:${infer Right}` ? [string, ...APIParameters<Right>] : [];

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './access.js';
 export * from './api.js';
 export * as icons from './icons.js';
+export * from './preferences.js';
 export * from './requests.js';
 export * from './schemas.js';
 export * from './user.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from './access.js';
 export * from './api.js';
 export * as icons from './icons.js';
+export * from './preferences.js';
 export * from './requests.js';
 export * from './schemas.js';
 export * from './user.js';

package/dist/preferences.d.ts

@@ -0,0 +1,39 @@
+import * as z from 'zod';
+/** @internal Used so we can narrow using `type` and get access to type-specific properties (e.g. `ZodNumber.minValue`) */
+type StringFormatTypes = z.ZodGUID | z.ZodUUID | z.ZodEmail | z.ZodURL | z.ZodEmoji | z.ZodNanoID | z.ZodCUID | z.ZodCUID2 | z.ZodULID | z.ZodXID | z.ZodKSUID | z.ZodISODateTime | z.ZodISODate | z.ZodISOTime | z.ZodISODuration | z.ZodIPv4 | z.ZodIPv6 | z.ZodCIDRv4 | z.ZodCIDRv6 | z.ZodBase64 | z.ZodBase64URL | z.ZodE164 | z.ZodJWT;
+type ZodPrefPrimitive = z.ZodString | z.ZodNumber | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodLiteral | z.ZodTemplateLiteral | z.ZodFile | z.ZodEnum | StringFormatTypes;
+type ZodPrefComposite = ZodPrefPrimitive | z.ZodNullable<ZodPrefPrimitive> | z.ZodOptional<ZodPrefPrimitive> | z.ZodArray<ZodPrefPrimitive> | z.ZodTuple<ZodPrefPrimitive[]> | z.ZodRecord<z.ZodString, ZodPrefPrimitive> | z.ZodObject<Readonly<Record<string, ZodPrefPrimitive>>>;
+/** @internal Used so we can narrow using `type` and get access to type-specific properties (e.g. `ZodNumber.minValue`) */
+export type ZodPref = ZodPrefComposite | z.ZodObject<Readonly<Record<string, ZodPrefComposite>>>;
+/**
+ * Interface for the user preferences schema shape.
+ * Modify with `declare module ...`.
+ */
+export interface PreferenceSchemas {
+    debug: z.ZodBoolean;
+}
+export type PreferenceName = keyof PreferenceSchemas & string;
+/**
+ * @internal
+ */
+export declare const preferenceSchemas: PreferenceSchemas;
+export type Preferences = z.infer<z.ZodObject<Readonly<PreferenceSchemas>>>;
+/**
+ * @internal
+ */
+export declare const preferenceDefaults: Preferences;
+/**
+ * @internal
+ * @todo Implement proper localization
+ */
+export declare const preferenceLabels: Record<PreferenceName, string>;
+export declare const preferenceDescriptions: Partial<Record<PreferenceName, string>>;
+export interface PreferenceInit<T extends PreferenceName = PreferenceName> {
+    name: T;
+    schema: PreferenceSchemas[T] & ZodPref;
+    initial: z.infer<PreferenceSchemas[T] & ZodPref>;
+    label: string;
+    descriptions?: string;
+}
+export declare function addPreference<T extends PreferenceName = PreferenceName>(init: PreferenceInit<T>): void;
+export {};

package/dist/preferences.js

@@ -0,0 +1,27 @@
+import * as z from 'zod';
+/**
+ * @internal
+ */
+export const preferenceSchemas = {
+    debug: z.boolean(),
+};
+/**
+ * @internal
+ */
+export const preferenceDefaults = {
+    debug: false,
+};
+/**
+ * @internal
+ * @todo Implement proper localization
+ */
+export const preferenceLabels = {
+    debug: 'Debug mode',
+};
+export const preferenceDescriptions = {};
+export function addPreference(init) {
+    preferenceSchemas[init.name] = init.schema;
+    preferenceDefaults[init.name] = init.initial;
+    preferenceLabels[init.name] = init.label;
+    preferenceDescriptions[init.name] = init.descriptions;
+}

package/dist/schemas.d.ts

@@ -1,4 +1,8 @@
 import * as z from 'zod';
+/** Needed for discriminated union type narrowing */
+export declare function zIs<const T extends z.core.$ZodTypeDef['type']>(schema: z.ZodType, type: T): schema is z.ZodType & {
+    type: T;
+};
 export declare function zFunction<T extends z.core.$ZodFunction>(schema: T): z.ZodCustom<Parameters<T["implement"]>[0], Parameters<T["implement"]>[0]>;
 export declare function zAsyncFunction<T extends z.core.$ZodFunction>(schema: T): z.ZodCustom<Parameters<T["implementAsync"]>[0], Parameters<T["implementAsync"]>[0]>;
 export declare const authenticatorAttachment: z.ZodOptional<z.ZodLiteral<"cross-platform" | "platform">>;

package/dist/schemas.js

@@ -1,4 +1,8 @@
 import * as z from 'zod';
+/** Needed for discriminated union type narrowing */
+export function zIs(schema, type) {
+    return schema.def.type == type;
+}
 export function zFunction(schema) {
     return z.custom((fn) => schema.implement(fn));
 }

package/dist/user.d.ts

@@ -1,10 +1,5 @@
 import * as z from 'zod';
-/**
- * User preferences.
- * Modify with `declare module ...`
- */
-export interface Preferences {
-}
+import type { Preferences } from './preferences.js';
 export declare const User: z.ZodObject<{
     id: z.ZodUUID;
     name: z.ZodString;
@@ -29,6 +24,8 @@ export declare const UserChangeable: z.ZodObject<{
     image: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodURL>>>;
     preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strip>;
-export type UserChangeable = z.infer<typeof UserChangeable>;
+export interface UserChangeable extends z.infer<typeof UserChangeable> {
+    preferences?: Preferences;
+}
 export declare function getUserImage(user: Partial<User>): string;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/core",
-	"version": "0.5.5",
+	"version": "0.6.0",
 	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
 	"funding": {
 		"type": "individual",