@sidekick-coder/zenith-kit 0.0.8 → 0.0.11

package/dist/shared/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/shared/index.d.mts

@@ -1,5 +1,54 @@
 import * as v from "valibot";
 
+//#region src/shared/services/ConfigService.d.ts
+interface Entry {
+  key: string;
+  value: any;
+  source: string;
+}
+declare class ConfigService {
+  entries: Map<string, Entry>;
+  constructor();
+  list(): Entry[];
+  parseValue(value: any): any;
+  loadFromRecord(record: Record<string, any>, source?: string): void;
+  loadFromEntries(entries: [string, any][], source?: string): void;
+  toRecord(): Record<string, any>;
+  has(key: string): boolean;
+  get<T = any | undefined>(key: string, defaultValue?: any): T;
+  getOne<T = any | undefined>(keys: string[], defaultValue?: any): T;
+  set(key: string, value: any, source?: string): void;
+  unset(key: string): void;
+  clear(): void;
+}
+//#endregion
+//#region src/shared/services/ContainerService.d.ts
+type Constructor$1<T = object> = new (...args: any[]) => T;
+type EntryKey = string | symbol | Constructor$1;
+declare class ContainerService {
+  private entries;
+  loadFromRecord(record: Record<string, any>): void;
+  toRecord(): Record<string, any>;
+  set(payload: EntryKey, value: any): void;
+  has(payload: EntryKey): boolean;
+  get<T>(payload: EntryKey): T;
+  singleton<T>(classConstructor: Constructor$1<T>): T;
+  load(entries: Record<any, any>): void;
+  proxy<T = unknown>(key: EntryKey): T;
+  keys(): EntryKey[];
+}
+//#endregion
+//#region src/shared/services/CookieService.d.ts
+declare class CookieService {
+  cookies: Map<string, string>;
+  prefix: string;
+  constructor(data?: Partial<CookieService>);
+  load(cookies: Record<string, string> | Map<string, string>): void;
+  get(name: string, defaultValue?: string | null): string | null;
+  set(name: string, value: string, options?: any): void;
+  toRecord(): Record<string, string>;
+}
+//#endregion
 //#region src/shared/services/LoggerService.d.ts
 declare class LoggerService {
   info(message: string, meta?: any): void;
@@ -10,10 +59,59 @@ declare class LoggerService {
 }
 //#endregion
 //#region src/shared/services/EmmitterService.d.ts
+interface EmmitterHandler {
+  id: string;
+  event: string;
+  listener: (...args: any[]) => any;
+  originalListener?: (...args: any[]) => any;
+}
+interface OnOptions {
+  id?: string;
+  unique?: boolean;
+}
+interface OnDebounceOptions extends OnOptions {
+  debounce?: number;
+}
 interface EmmitterServiceOptions {
   debug?: boolean;
   logger?: LoggerService;
 }
+declare class EmmitterService<Events extends Record<string, any> = Record<string, any>> {
+  private handlers;
+  private debug;
+  private logger;
+  load(options?: EmmitterServiceOptions): void;
+  on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;
+  on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;
+  once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;
+  once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;
+  onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler;
+  onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler;
+  onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[];
+  onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[];
+  off(event: string, listener: Function): void;
+  emit<K extends keyof Events>(event: K, args: Events[K]): void;
+  emit(event: string, args?: any): void;
+  emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>;
+  emitAndWait(event: string, args?: any): Promise<void>;
+  list(): EmmitterHandler[];
+  listByEvent(event: string): EmmitterHandler[];
+  remove(payload: string | string[]): void;
+  clear(): void;
+  hasHandlers(): boolean;
+}
+//#endregion
+//#region src/shared/entities/LifecycleHook.d.ts
+declare class LifecycleHook {
+  hook_id: string;
+  order?: number;
+  subhooks?: LifecycleHook[];
+  constructor();
+  onRegister(): Promise<void>;
+  onLoad(): Promise<void>;
+  onBoot(): Promise<void>;
+  onShutdown(): Promise<void>;
+}
 //#endregion
 //#region src/shared/utils/typing.d.ts
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
@@ -60,20 +158,88 @@ declare function compose<M extends Array<(base: Constructor<any>) => Constructor
 declare function composeWith<TBase extends Constructor, M extends Array<(base: Constructor) => Constructor<any>>>(baseClass: TBase, ...mixins: M): TBase & UnionToIntersection<ReturnType<M[number]>>;
 declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;
 //#endregion
+//#region src/shared/services/LifecycleService.d.ts
+interface ListOptions {
+  exclude?: (string | Constructor<LifecycleHook> | LifecycleHook)[];
+}
+declare class LifecycleService {
+  hooks: Map<string, LifecycleHook>;
+  logger: LoggerService;
+  debug: boolean;
+  constructor(data?: Partial<LifecycleService>);
+  private executeHookMethod;
+  list(options?: ListOptions): LifecycleHook[];
+  add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void;
+  register(options?: ListOptions): Promise<void>;
+  load(options?: ListOptions): Promise<void>;
+  boot(options?: ListOptions): Promise<void>;
+  shutdown(options?: ListOptions): Promise<void>;
+  clear(): void;
+}
+//#endregion
+//#region src/shared/services/TranslatorService.d.ts
+declare class TranslatorService {
+  entries: Map<string, string>;
+  locale: string;
+  localeLoaders: Map<string, () => Promise<Record<string, string>>>;
+  debug: boolean;
+  logger: LoggerService;
+  cache: Map<string, Record<string, string>>;
+  constructor(data?: Partial<TranslatorService>);
+  get locales(): string[];
+  list(): {
+    key: string;
+    value: string;
+  }[];
+  getEntries(locale: string): Promise<Record<string, string>>;
+  load(locale: string): Promise<void>;
+  t(key: string, args?: any): string;
+  date(data: string | number | Date): string;
+  datetime(data: string | number | Date): string;
+}
+//#endregion
+//#region src/shared/services/UploadService.d.ts
+declare class UploadService {
+  single(name: string): void;
+  multiple(name: string): void;
+}
+declare namespace url_d_exports {
+  export { array, arrayNumber, boolean, date, datetime, number, object };
+}
+declare const number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;
+declare const boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;
+declare const date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string | Date>]>;
+declare const datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | Date>]>;
+declare const array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;
+declare const arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;
+declare const object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {
+  [x: string]: any;
+}, {
+  [x: string]: any;
+}>, v.TransformAction<{
+  [x: string]: any;
+}, Record<string, any>>]>;
+//#endregion
 //#region src/shared/services/ValidatorService.d.ts
-type Valibot = typeof v;
+declare const extras: {
+  url: typeof url_d_exports;
+};
+type Valibot = typeof v & {
+  extras: typeof extras;
+};
 type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;
 type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;
 interface ValidatorCallback<T extends ValibotSchema> {
-  (_v: typeof v): T;
+  (_v: Valibot): T;
 }
 type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {
-  (_v: typeof v): T;
+  (_v: Valibot): T;
 };
 type ValidatorResult<T extends v.ObjectEntries> = v.InferOutput<v.ObjectSchema<T, undefined>>;
 type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;
 type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;
 declare class ValidatorService {
+  v: Valibot;
   create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;
   validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;
   validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;
@@ -107,4 +273,109 @@ declare namespace tryCatch {
   var sync: <T extends Tryer>(tryer: T) => TryCatchResult<T>;
 }
 //#endregion
-export { AnyClass, Constructor, EmmitterServiceOptions, Mixin, PartialBy, PublicData, UnionToIntersection, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, tryCatch, unflatten };
+//#region src/shared/schemas/permissionAssignmentSchema.d.ts
+type PermissionAssignment = v.InferOutput<typeof permissionAssignmentSchema>;
+declare const permissionAssignmentSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly permission_id: v.NumberSchema<undefined>;
+  readonly assignable_type: v.StringSchema<undefined>;
+  readonly assignable_id: v.StringSchema<undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/schemas/permissionSchema.d.ts
+type Permission = v.InferOutput<typeof permissionSchema>;
+declare const permissionSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly action: v.StringSchema<undefined>;
+  readonly subject: v.StringSchema<undefined>;
+  readonly conditions: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+  readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/schemas/tokenSchema.d.ts
+type Token = v.InferOutput<typeof tokenSchema>;
+declare const tokenSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly type: v.StringSchema<undefined>;
+  readonly user_id: v.NumberSchema<undefined>;
+  readonly token: v.StringSchema<undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+  readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/exceptions/BaseException.d.ts
+declare class BaseException extends Error {
+  statusCode: number;
+  constructor(message: string, statusCode?: number);
+  static fromError(error: Error): BaseException;
+}
+//#endregion
+//#region src/shared/exceptions/ShellException.d.ts
+declare class ShellException extends BaseException {
+  output: string;
+  bin: string;
+  args: string[];
+  constructor(message: string, output: string, bin: string, args: string[]);
+}
+//#endregion
+//#region src/shared/facades/validator.d.ts
+declare const validator: ValidatorService;
+//#endregion
+//#region src/shared/entities/ModuleManifestEntity.d.ts
+interface ModuleManifestBuildImport {
+  from: string;
+  to?: string;
+  type: 'global_import';
+}
+interface ModuleManifestBuild {
+  imports?: ModuleManifestBuildImport[];
+}
+declare const ModuleManifest_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor;
+declare class ModuleManifest extends ModuleManifest_base {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  enabled: boolean;
+  author?: string;
+  dependencies?: Record<string, string>;
+  build?: ModuleManifestBuild;
+  [key: string]: any;
+}
+//#endregion
+//#region src/shared/entities/ModuleEntity.d.ts
+interface ModuleUpgradeInfo {
+  source: 'git' | 'zip';
+  [key: string]: any;
+}
+declare const Module_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & Constructor<{}> & typeof LifecycleHook;
+declare class Module extends Module_base {
+  id: string;
+  name: string;
+  enabled: boolean;
+  dependencies: Record<string, any>;
+  build: ModuleManifest['build'];
+  directory: string;
+  upgrade_info?: ModuleUpgradeInfo;
+  setData(data: Partial<Module | ModuleManifest>): void;
+}
+//#endregion
+export { AnyClass, BaseException, ConfigService, Constructor, ContainerService, CookieService, EmmitterService, EmmitterServiceOptions, LifecycleHook, LifecycleService, LoggerService, Mixin, Module as ModuleEntity, ModuleManifestBuild, ModuleManifestBuildImport, ModuleManifest as ModuleManifestEntity, PartialBy, Permission, PermissionAssignment, PublicData, ShellException, Token, TranslatorService, UnionToIntersection, UploadService, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, permissionAssignmentSchema, permissionSchema, tokenSchema, tryCatch, unflatten, validator };