akanjs 2.2.4 → 2.2.6

package/signal/trace.ts

@@ -81,13 +81,6 @@ export class SignalTrace {
   }
 }
 
-// Shared across bundle chunks (see traceAggregator note) so that span/db/cache helpers
-// invoked from other modules (database.resolver, middleware) observe the active trace.
-// Shared store pinned to `process`. The akan worker loads the app server bundle and the
-// framework runtime in separate module realms (each with its own `globalThis`), so the
-// signal layer that records spans and the metrics collector that reads them would otherwise
-// hold different singletons. `process` is the one object shared across realms in a single OS
-// process, so we hang the trace ALS + aggregator off it to guarantee a single instance.
 const traceProcessStore = process as unknown as {
   __akanTraceAls?: AsyncLocalStorage<SignalTrace>;
   __akanTraceAggregator?: TraceAggregator;
@@ -253,10 +246,6 @@ const round = (value: number, digits = 3): number => {
   return Math.round(value * factor) / factor;
 };
 
-// The akan build can bundle this module into more than one chunk (e.g. the signal layer
-// that writes spans vs. the metrics collector that reads them). A plain module-level
-// singleton would then diverge per chunk, so pin it to globalThis to guarantee that every
-// copy of this module shares one aggregator within the process.
 let aggregatorInstance = traceProcessStore.__akanTraceAggregator;
 if (!aggregatorInstance) {
   aggregatorInstance = new TraceAggregator();

package/signal/types.ts

@@ -4,11 +4,6 @@ import type { GuardCls } from "./guard";
 import type { MiddlewareCls } from "./middleware";
 import type { SliceCls } from "./slice";
 
-// --- ServiceModel projection helpers (D1) ---
-// Use these instead of re-typing `NonNullable<SrvModule["cnst"]>["_Full"]` /
-// `SlceCls["srv"]["cnst"]["_Full"]` everywhere. Centralizing the path keeps
-// type derivations consistent and dramatically reduces the amount of text
-// TypeScript has to re-evaluate at each callsite.
 export type CnstOf<S extends ServiceModel> = NonNullable<S["cnst"]>;
 export type DbOf<S extends ServiceModel> = NonNullable<S["db"]>;
 
@@ -28,8 +23,6 @@ export type CnstCapitalizedRefName<S extends ServiceModel> = CnstOf<S>["_Capital
 export type DbFilter<S extends ServiceModel> = DbOf<S>["_Filter"];
 export type DbSort<S extends ServiceModel> = DbOf<S>["_Sort"];
 
-// Slice-cls shortcuts (common in store/state/action). The branches that
-// include `SlceCls extends SliceCls` preserve `ServiceModel` inference.
 export type SlceSrv<S extends SliceCls> = S["srv"];
 export type SlceCnstRefName<S extends SliceCls> = S["srv"]["cnst"]["refName"];
 export type SlceCnstInput<S extends SliceCls> = S["srv"]["cnst"]["_Input"];
@@ -80,13 +73,11 @@ export interface SignalOption<Response = any, Nullable extends boolean = false,
   /** Marks this mutation as the framework file-upload endpoint (see resolveFileUploadCapability). */
   fileUpload?: boolean;
 
-  // * ==================== Schedule ==================== * //
   scheduleType?: "init" | "destroy" | "cron" | "interval" | "timeout";
   scheduleCron?: string;
   scheduleTime?: number;
   lock?: boolean;
   enabled?: boolean;
-  // * ==================== Schedule ==================== * //
 }
 
 interface SerializedSignalOption {
@@ -101,7 +92,7 @@ export interface SerializedSlice extends SerializedSignalOption {}
 
 export interface SerializedReturns {
   refName: Exclude<DefaultPrimitiveName, "Map" | "Upload"> | (string & {});
-  modelType?: "input" | "full" | "light" | "insight" | "scalar"; // undefined when primitive
+  modelType?: "input" | "full" | "light" | "insight" | "scalar"; 
   arrDepth?: number;
   partial?: string[];
   nullable?: boolean;
@@ -110,7 +101,7 @@ export interface SerializedArg {
   type: ArgType;
   refName: Exclude<DefaultPrimitiveName, "Map"> | (string & {});
   name: string;
-  modelType?: "input" | "object" | "insight" | "scalar"; // undefined when primitive
+  modelType?: "input" | "object" | "insight" | "scalar"; 
   arrDepth?: number;
   nullable?: boolean;
   example?: string | number | boolean | Date;

package/store/action.ts

@@ -783,7 +783,6 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       const currentState = this.get() as { [key: string]: any };
       if (fullOrLightModels.length === 0) return;
 
-      // set the first model to the model state
       const firstModel = fullOrLightModels[0];
       const model = currentState[names.model] as Full | null;
       const isFull = firstModel instanceof modelRef;
@@ -798,7 +797,6 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         this.set({ [names.model]: crystalizedModel });
       }
 
-      // set the rest of the models to the model list
       const lightModels = fullOrLightModels.map(
         (fullOrLightModel) => new cnst.light().set(fullOrLightModel) as unknown as Light,
       );
@@ -907,7 +905,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
           limit === limitOfModel &&
           isQueryEqual(sort as unknown as object, sortOfModel as unknown as object)
         )
-          return; // store-level cache hit
+          return; 
         else this.set({ [namesOfSlice.modelListLoading]: true });
         const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
         const [modelDataList, modelInsight] = await Promise.all([
@@ -1046,7 +1044,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (isQueryEqual(queryArgsOfModel, queryArgs)) {
           Logger.trace(`${namesOfSlice.queryArgsOfModel} store-level cache hit`);
-          return; // store-level cache hit
+          return; 
         }
         this.set({ [namesOfSlice.modelListLoading]: true });
         const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
@@ -1079,7 +1077,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel] as object[];
         const limitOfModel = currentState[namesOfSlice.limitOfModel] as number;
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
-        if (sortOfModel === sort) return; // store-level cache hit
+        if (sortOfModel === sort) return; 
         this.set({ [namesOfSlice.modelListLoading]: true });
         const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
         const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(

package/store/stateBuilder.ts

@@ -278,7 +278,6 @@ export const makeDefaultFactory = (value: unknown): StateInitializer => {
         try {
           return structuredClone(value);
         } catch {
-          // Fall back to recursive clone for class-like plain data.
         }
       }
       return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, makeDefaultFactory(val)()]));
@@ -415,7 +414,6 @@ const getSessionKey = () => {
       sessionStorage.setItem(key, next);
       return next;
     } catch {
-      // fall through
     }
   }
   memorySessionKey ??= Math.random().toString(36).slice(2);

package/store/stateInfo.ts

@@ -1,14 +1,13 @@
 import type { EnumInstance, PrimitiveScalar } from "akanjs/base";
 import type { ConstantFieldTypeInput, PlainTypeToFieldType } from "akanjs/constant";
 
-// not implemented
 export type StateType = "normal" | "storage" | "cookie" | "param" | "searchParam";
 
 export interface StateProps<FieldValue = any, MapValue = any, Nullable extends boolean = false> {
   nullable: Nullable;
   default?: FieldValue | ((doc: { id: string }) => FieldValue);
   enum?: EnumInstance;
-  of?: MapValue; // for Map type fields
+  of?: MapValue; 
 }
 
 export class StateInfo<

package/store/types.ts

@@ -16,7 +16,7 @@ type PickFunc<
   F extends keyof State = IsAny<State> extends true ? any : keyof State extends never ? any : keyof State,
 > = (...fields: F[]) => {
   [K in (typeof fields)[number]]: Exclude<State[K], null | undefined | "loading">;
-}; // & { [K in keyof T as T[K] extends (...args: any) => any ? K : never]: T[K] };
+}; 
 export interface SetGet<State = any> {
   set: (setState: Partial<State> | ((state: State) => void)) => void;
   get: () => State;

package/test/playwright.config.base.ts

@@ -1,8 +1,7 @@
-// import { workspaceRoot } from "@nx/devkit";
-// import { nxE2EPreset } from "@nx/playwright/preset";
+
+
 import { defineConfig, devices, type PlaywrightTestConfig } from "@playwright/test";
 
-// For CI, you may want to set BASE_URL to the deployed application.
 const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
 const projectName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
 
@@ -10,26 +9,23 @@ const projectName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
  * Read environment variables from file.
  * https://github.com/motdotla/dotenv
  */
-// require('dotenv').config();
 
 /**
  * See https://playwright.dev/docs/test-configuration.
  */
 export const withBase = (filename: string, config: PlaywrightTestConfig = {}) =>
   defineConfig({
-    // ...nxE2EPreset(filename, { testDir: "./app" }),
-    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+
     use: {
       baseURL,
-      /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+      
       trace: "on-first-retry",
     },
-    /* Run your local dev server before starting the tests */
+    
     webServer: {
       command: `akan serve ${projectName}`,
       url: "http://127.0.0.1:4200",
       reuseExistingServer: !process.env.CI,
-      // cwd: workspaceRoot,
     },
     projects: [
       {
@@ -47,25 +43,6 @@ export const withBase = (filename: string, config: PlaywrightTestConfig = {}) =>
         use: { ...devices["Desktop Safari"] },
       },
 
-      // Uncomment for mobile browsers support
-      /* {
-      name: 'Mobile Chrome',
-      use: { ...devices['Pixel 5'] },
-    },
-    {
-      name: 'Mobile Safari',
-      use: { ...devices['iPhone 12'] },
-    }, */
-
-      // Uncomment for branded browsers
-      /* {
-      name: 'Microsoft Edge',
-      use: { ...devices['Desktop Edge'], channel: 'msedge' },
-    },
-    {
-      name: 'Google Chrome',
-      use: { ...devices['Desktop Chrome'], channel: 'chrome' },
-    } */
     ],
     ...config,
   });

package/test/playwright.pageAgent.ts

@@ -13,7 +13,7 @@ export class PageAgent {
   async goto(path: string) {
     await Promise.all([this.page.goto(path), this.waitForPathChange(path)]);
     if (!this.#isInitialized) {
-      // await this.page.waitForEvent("websocket");
+      
       this.#isInitialized = true;
     }
   }

package/test/sampleOf.ts

@@ -60,7 +60,7 @@ export type SampleOf<Model> = DocumentModel<{
 export const sampleOf = <Model>(
   modelRef: ConstantCls<Model>,
 ): DocumentModel<{ [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]> }> => {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  
   return Object.fromEntries(
     Object.entries(modelRef[FIELD_META]).map(([key, field]) => [
       key,

package/test/testServer.ts

@@ -149,7 +149,7 @@ export class TestServer {
   async terminate() {
     const now = Date.now();
     const elapsed = now - this.#startAt;
-    await sleep(50); // cooldown
+    await sleep(50); 
     await this.#server?.stop();
     this.#server = undefined;
     if (this.#tempDir) {

package/types/base/base.d.ts

@@ -0,0 +1,53 @@
+import type { Cls } from ".";
+import { Float, Int } from "./primitiveRegistry.d.ts";
+export type EnumInstance<RefName extends string = string, T = string | number> = Cls<{
+    refName: RefName;
+    value: T;
+}, {
+    refName: RefName;
+    type: StringConstructor | typeof Int | typeof Float;
+    values: readonly T[];
+    valueMap: Map<T, number>;
+    has: (value: T) => boolean;
+    indexOf: (value: T) => number;
+    find: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T;
+    findIndex: (callback: (value: T, index: number, array: readonly T[]) => boolean) => number;
+    filter: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T[];
+    map: <R>(callback: (value: T, index: number, array: readonly T[]) => R) => R[];
+    forEach: (callback: (value: T, index: number, array: readonly T[]) => void) => void;
+}>;
+/** Returns true when a class was created by `enumOf`. */
+export declare const isEnum: (enumRef: Cls) => boolean;
+/** Creates a typed scalar enum class from a readonly list of string or number values. */
+export declare const enumOf: <RefName extends string, T = string | number>(refName: RefName, values: readonly T[]) => EnumInstance<RefName, T>;
+/** Id-keyed list helper used for light model collections and immutable-style list updates. */
+export declare class DataList<Light extends {
+    id: string;
+}> {
+    #private;
+    length: number;
+    values: Light[];
+    constructor(data?: Light[] | DataList<Light>);
+    indexOf(id: string): number;
+    set(value: Light): this;
+    delete(id: string): this;
+    get(id: string): Light | undefined;
+    at(idx: number): Light | undefined;
+    pickAt(idx: number): Light;
+    pick(id: string): Light;
+    has(id: string): boolean;
+    find(fn: (value: Light, idx: number) => boolean): Light | undefined;
+    findIndex(fn: (value: Light, idx: number) => boolean): number;
+    some(fn: (value: Light, idx: number) => boolean): boolean;
+    every(fn: (value: Light, idx: number) => boolean): boolean;
+    forEach(fn: (value: Light, idx: number) => void): void;
+    map<T>(fn: (value: Light, idx: number) => T): T[];
+    flatMap<T>(fn: (value: Light, idx: number, array: Light[]) => T | readonly T[]): T[];
+    sort(fn: (a: Light, b: Light) => number): DataList<Light>;
+    filter(fn: (value: Light, idx: number) => boolean): DataList<Light>;
+    reduce<T>(fn: (acc: T, value: Light, idx: number) => T, initialValue: T): T;
+    slice(start: number, end?: number): DataList<Light>;
+    save(): DataList<Light>;
+    [Symbol.iterator](): ArrayIterator<Light>;
+}
+export declare const logo = "\n     _    _                  _     \n    / \\  | | ____ _ _ __    (_)___ \n   / _ \\ | |/ / _' | '_ \\   | / __|\n  / ___ \\|   < (_| | | | |_ | \\__ \\\n /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/\n                          |__/      \n? See more details on docs  https://www.akanjs.com/docs\n\u2605 Star Akanjs on GitHub     https://github.com/akan-team/akanjs\n\n";

package/types/base/baseEnv.d.ts

@@ -0,0 +1,68 @@
+export type Environment = "testing" | "debug" | "develop" | "main" | "local";
+export type DatabaseMode = "single" | "multiple" | "cluster";
+export interface BaseEnv {
+    repoName: string;
+    serveDomain: string;
+    appName: string;
+    environment: Environment;
+    operationMode: "local" | "edge" | "cloud" | "module";
+    tunnelUsername: string;
+    tunnelPassword: string;
+    databaseMode?: DatabaseMode;
+}
+export type BackendEnv = BaseEnv & {
+    hostname?: string | null;
+    port?: number;
+    database?: {
+        mode?: DatabaseMode;
+        driver?: "sqlite" | "libsql" | "postgres";
+        sqlite?: {
+            filePath?: string;
+            journalMode?: string;
+            busyTimeoutMs?: number;
+            synchronous?: string;
+            foreignKeys?: boolean;
+            cacheSize?: number;
+            tempStore?: string;
+        };
+        libsql?: {
+            url?: string;
+            authToken?: string;
+        };
+        postgres?: {
+            url?: string;
+            host?: string;
+            port?: number;
+            database?: string;
+            user?: string;
+            password?: string;
+        };
+    };
+    solid?: {
+        filePath?: string;
+        journalMode?: string;
+        busyTimeoutMs?: number;
+        synchronous?: string;
+        cleanupIntervalMs?: number;
+        queuePollIntervalMs?: number;
+        queueLeaseMs?: number;
+    };
+    onCleanup?: () => Promise<void>;
+};
+export type ClientEnv = BaseEnv & {
+    side: "server" | "client";
+    renderMode: "ssr" | "csr";
+    websocket: boolean;
+    clientHost: string;
+    clientPort: number;
+    clientHttpProtocol: "http:" | "https:";
+    clientHttpUri: string;
+    serverHost: string;
+    serverPort: number;
+    serverHttpProtocol: "http:" | "https:";
+    serverHttpUri: string;
+    serverWsProtocol: "ws:" | "wss:";
+    serverWsUri: string;
+};
+/** Reads and caches Akan runtime environment values from process/browser environment settings. */
+export declare const getEnv: () => ClientEnv;

package/types/base/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./base.d.ts";
+export * from "./baseEnv.d.ts";
+export * from "./primitiveRegistry.d.ts";
+export * from "./symbols.d.ts";
+export * from "./types.d.ts";
+export * from "./utils.d.ts";

package/types/base/primitiveRegistry.d.ts

@@ -0,0 +1,134 @@
+import dayjsLib, { type Dayjs } from "dayjs";
+import type { Cls } from "./types.d.ts";
+export type { Dayjs };
+/** Shared dayjs factory re-export used by Akan documents, services, stores, and UI. */
+export declare const dayjs: typeof dayjsLib;
+/** Registry that maps Akan primitive scalar names to their runtime scalar classes. */
+export declare class PrimitiveRegistry {
+    #private;
+    static register(scalar: typeof PrimitiveScalar, { overwrite }?: {
+        overwrite?: boolean | undefined;
+    }): void;
+    static get(name: string): typeof PrimitiveScalar;
+    static getName(scalar: typeof PrimitiveScalar): string;
+    static has(modelRef: Cls): boolean;
+    static hasName(name: string): boolean;
+    static getNames(): string[];
+    static getAll(): (typeof PrimitiveScalar)[];
+}
+export declare const PRIMITIVE_SERVER_VALUE: unique symbol;
+export declare const PRIMITIVE_CLIENT_VALUE: unique symbol;
+export declare const PRIMITIVE_DEFAULT_VALUE: unique symbol;
+export declare const PRIMITIVE_EXAMPLE_VALUE: unique symbol;
+export type PrimitiveValue = string | number | boolean | Dayjs | Date | null | undefined;
+export declare class PrimitiveScalar {
+    static refName: string;
+    static [PRIMITIVE_SERVER_VALUE]: unknown;
+    static [PRIMITIVE_CLIENT_VALUE]: unknown;
+    static [PRIMITIVE_DEFAULT_VALUE]: unknown;
+    static [PRIMITIVE_EXAMPLE_VALUE]: unknown;
+    static validate(value: PrimitiveValue): boolean;
+    static parseValue(value: PrimitiveValue): PrimitiveValue;
+    static serializeValue(value: PrimitiveValue): PrimitiveValue;
+    static _parse(this: typeof PrimitiveScalar, input: PrimitiveValue, { optional }?: {
+        optional?: boolean;
+    }): PrimitiveValue;
+    static _serialize(this: typeof PrimitiveScalar, value: PrimitiveValue, { optional }?: {
+        optional?: boolean;
+    }): PrimitiveValue;
+    static _checkValue(this: typeof PrimitiveScalar, value: PrimitiveValue, { optional }?: {
+        optional?: boolean;
+    }): void;
+}
+/** Integer primitive scalar. Accepts safe integer numbers after parsing. */
+export declare class Int extends PrimitiveScalar {
+    static refName: "Int";
+    static [PRIMITIVE_SERVER_VALUE]: number;
+    static [PRIMITIVE_CLIENT_VALUE]: number;
+    static [PRIMITIVE_DEFAULT_VALUE]: number;
+    static [PRIMITIVE_EXAMPLE_VALUE]: number;
+    static validate(value: string | number): boolean;
+    static parseValue(input: string | number): number;
+    static serializeValue(value: number): number;
+}
+/** Floating point primitive scalar. Accepts finite numbers after parsing. */
+export declare class Float extends PrimitiveScalar {
+    static refName: "Float";
+    static [PRIMITIVE_SERVER_VALUE]: number;
+    static [PRIMITIVE_CLIENT_VALUE]: number;
+    static [PRIMITIVE_DEFAULT_VALUE]: number;
+    static [PRIMITIVE_EXAMPLE_VALUE]: number;
+    static validate(value: string | number): boolean;
+    static parseValue(input: string | number): number;
+    static serializeValue(value: number): number;
+}
+/** 24-character hexadecimal id primitive used by Akan document and signal models. */
+export declare class ID extends PrimitiveScalar {
+    static refName: "ID";
+    static [PRIMITIVE_SERVER_VALUE]: string;
+    static [PRIMITIVE_CLIENT_VALUE]: string;
+    static [PRIMITIVE_DEFAULT_VALUE]: string;
+    static [PRIMITIVE_EXAMPLE_VALUE]: string;
+    static validate(value: string): boolean;
+    static parseValue(input: string): string;
+    static serializeValue(value: string): string;
+    static _checkValue(value: PrimitiveValue, options?: {
+        optional?: boolean;
+    }): void;
+}
+/** Open object primitive for intentionally flexible payloads or metadata blobs. */
+export declare class Any extends PrimitiveScalar {
+    static refName: "Any";
+    static [PRIMITIVE_DEFAULT_VALUE]: object | null;
+    static [PRIMITIVE_EXAMPLE_VALUE]: object;
+}
+export declare class Upload extends PrimitiveScalar {
+    static refName: "Upload";
+    static [PRIMITIVE_SERVER_VALUE]: File;
+    static [PRIMITIVE_CLIENT_VALUE]: File;
+    static [PRIMITIVE_DEFAULT_VALUE]: File | null;
+    static [PRIMITIVE_EXAMPLE_VALUE]: string;
+    __TEMP_TYPE__: "Upload";
+}
+declare global {
+    interface StringConstructor {
+        refName: "String";
+        [PRIMITIVE_SERVER_VALUE]: string;
+        [PRIMITIVE_CLIENT_VALUE]: string;
+        [PRIMITIVE_DEFAULT_VALUE]: string;
+        [PRIMITIVE_EXAMPLE_VALUE]: string;
+        validate(value: string): boolean;
+        parseValue(input: string): string;
+        serializeValue(value: string): string;
+        _parse(input: string): string;
+        _serialize(value: string): string;
+        _checkValue(value: string): void;
+    }
+    interface BooleanConstructor {
+        refName: "Boolean";
+        [PRIMITIVE_SERVER_VALUE]: boolean;
+        [PRIMITIVE_CLIENT_VALUE]: boolean;
+        [PRIMITIVE_DEFAULT_VALUE]: boolean;
+        [PRIMITIVE_EXAMPLE_VALUE]: boolean;
+        validate(value: boolean): boolean;
+        parseValue(input: boolean): boolean;
+        serializeValue(value: boolean): boolean;
+        _parse(input: boolean): boolean;
+        _serialize(value: boolean): boolean;
+        _checkValue(value: boolean): void;
+    }
+    interface DateConstructor {
+        refName: "Date";
+        [PRIMITIVE_SERVER_VALUE]: Dayjs;
+        [PRIMITIVE_CLIENT_VALUE]: Dayjs;
+        [PRIMITIVE_DEFAULT_VALUE]: Dayjs;
+        [PRIMITIVE_EXAMPLE_VALUE]: string;
+        validate(value: Date): boolean;
+        parseValue(input: Date): Dayjs;
+        serializeValue(value: Dayjs | Date): Date;
+        _parse(input: Date): Dayjs;
+        _serialize(value: Dayjs | Date): Date;
+        _checkValue(value: Date): void;
+    }
+}
+export type DefaultPrimitiveName = "String" | "Boolean" | "Date" | "Int" | "Float" | "ID" | "Any" | "Upload";

package/types/base/symbols.d.ts

@@ -0,0 +1,11 @@
+export declare const FIELD_META: unique symbol;
+export declare const SLICE_META: unique symbol;
+export declare const FILTER_META: unique symbol;
+export declare const LOADER_META: unique symbol;
+export declare const INJECT_META: unique symbol;
+export declare const ENDPOINT_META: unique symbol;
+export declare const INTERNAL_META: unique symbol;
+export declare const STATE_META: unique symbol;
+export declare const STATE_INIT_META: unique symbol;
+export declare const STATE_DERIVED_META: unique symbol;
+export declare const ACTION_META: unique symbol;

package/types/base/types.d.ts

@@ -0,0 +1,68 @@
+import type { Dayjs } from "dayjs";
+export type SshOptions = {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    dstPort?: number;
+};
+export type Cls<T = unknown, Statics = unknown> = (new (...args: never[]) => T) & Statics;
+export type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly unknown[] | readonly number[];
+export type GetObject<T> = {
+    [K in keyof T as K extends "prototype" ? never : K]: T[K];
+};
+export type OptionOf<Obj> = Partial<{
+    [K in keyof Obj]: Obj[K] | null;
+}>;
+export type UnCls<T> = T extends new (...args: infer _Args) => infer U ? U : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type GetStateObject<T> = {
+    [K in keyof T as T[K] extends (...args: never[]) => unknown ? never : K extends "prototype" ? never : K]: T[K];
+};
+export type GetActionObject<T> = {
+    [K in keyof T as T[K] extends (...args: never[]) => unknown ? (K extends "prototype" ? never : K) : never]: T[K];
+};
+export type PromiseOrObject<T> = T | Promise<T>;
+type MergeObjectValues<T> = T extends Record<string, infer V> ? (V extends object ? V : never) : never;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type MergedValues<T> = UnionToIntersection<MergeObjectValues<T>>;
+export type Assign<A, B> = Omit<A, keyof B> & B;
+export type ObjectAssign<Objects extends object[], Acc = unknown> = Objects extends [
+    infer First extends object,
+    ...infer Rest extends object[]
+] ? ObjectAssign<Rest, Assign<Acc, First>> : Acc;
+export type MergeAll<T extends object[], Acc = unknown> = T extends [
+    infer First extends object,
+    ...infer Rest extends object[]
+] ? MergeAll<Rest, Acc & First> : Acc;
+export type MergeAllActionTypes<T extends Cls[], OmitKey extends string = never, Acc = unknown> = T extends [
+    infer First extends Cls,
+    ...infer Rest extends Cls[]
+] ? Rest extends [] ? Acc & Omit<GetActionObject<UnCls<First>>, OmitKey> : MergeAllActionTypes<Rest, OmitKey, Acc & Omit<UnCls<First>, OmitKey>> : Acc;
+export type MergeAllTypes<T extends Cls[], OmitKey extends string = never, Acc = unknown> = T extends [
+    infer First extends Cls,
+    ...infer Rest extends Cls[]
+] ? MergeAllTypes<Rest, OmitKey, Acc & Omit<UnCls<First>, OmitKey>> : Acc;
+export type MergeAllKeyOfTypes<T extends Cls<object>[], Key extends PropertyKey, Acc = unknown> = T extends [
+    infer First extends Cls<object>,
+    ...infer Rest extends Cls<object>[]
+] ? Key extends keyof UnCls<First> ? MergeAllKeyOfTypes<Rest, Key, Acc & UnCls<First>[Key]> : MergeAllKeyOfTypes<Rest, Key, Acc> : Acc;
+export type MergeAllKeyOfObjects<T extends object[], Key extends PropertyKey, Acc = unknown> = T extends [
+    infer First extends object,
+    ...infer Rest extends object[]
+] ? Key extends keyof First ? MergeAllKeyOfObjects<Rest, Key, Acc & First[Key]> : MergeAllKeyOfObjects<Rest, Key, Acc> : Acc;
+export type MergeAllDoubleKeyOfObjects<T extends object[], Key extends PropertyKey, SubKey extends PropertyKey, Acc = unknown> = T extends [infer First extends object, ...infer Rest extends object[]] ? Key extends keyof First ? First[Key] extends object ? SubKey extends keyof First[Key] ? MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc & First[Key][SubKey]> : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc> : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc> : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc> : Acc;
+export type Primitive = string | number | boolean | null | undefined;
+export type NestedKeysWithAllowed<T, Allowed = Primitive> = T extends Primitive ? never : T extends unknown[] ? never : T extends (...args: never[]) => unknown ? never : {
+    [K in keyof T & string]: T[K] extends Allowed ? K : T[K] extends Dayjs ? never : T[K] extends readonly unknown[] ? never : T[K] extends (...args: never[]) => unknown ? never : T[K] extends object ? K | `${K}.${NestedKeysWithAllowed<T[K], Allowed>}` : never;
+}[keyof T & string];
+export type SingleValue<Value> = Value extends (infer V)[] ? SingleValue<V> : Value;
+export type StrArrToObject<Arr, Value> = Arr extends [infer First, ...infer Rest] ? {
+    [K in First & string]: Value;
+} & StrArrToObject<Rest, Value> : unknown;
+export type GetValueOfKey<Model, Key extends string, Fallback = never> = Model extends {
+    [key in Key]: unknown;
+} ? Model[Key] : Fallback;
+export {};

package/types/base/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const getNonArrayModel: <T>(arraiedModel: T | T[]) => [T, number];
+export declare const arraiedModel: <T = unknown>(modelRef: T, arrDepth?: number) => T | T[];
+export type ApplyFnToArrayObjectsResult<Input, Output> = Input extends readonly (infer Item)[] ? ApplyFnToArrayObjectsResult<Item, Output>[] : Output;
+export declare const applyFnToArrayObjects: <Input, Fn extends (arg: never) => unknown>(arraiedData: Input, fn: Fn) => ApplyFnToArrayObjectsResult<Input, ReturnType<Fn>>;

package/types/base.d.ts

@@ -0,0 +1 @@
+export * from "./base/index.d.ts";

package/types/capacitor.base.config.d.ts

@@ -0,0 +1,3 @@
+import type { CapacitorConfig } from "@capacitor/cli";
+import type { AkanMobileTargetConfig, AppScanResult } from "akanjs";
+export declare const withBase: (configImp?: (config: CapacitorConfig, target: AkanMobileTargetConfig) => CapacitorConfig, appData?: AppScanResult, targetName?: string) => CapacitorConfig;