@akanjs/base 0.0.39 → 0.0.41

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/base",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"

package/src/base.d.ts

@@ -0,0 +1,47 @@
+export declare class Enum<T> {
+    readonly values: T[];
+    readonly value: T;
+    readonly valueMap: Map<T, number>;
+    constructor(values: T[]);
+    has(value: T): boolean;
+    indexOf(value: T): number;
+    find(callback: (value: T, index: number, array: T[]) => boolean): T;
+    findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
+    filter(callback: (value: T, index: number, array: T[]) => boolean): T[];
+    map<R>(callback: (value: T, index: number, array: T[]) => R): R[];
+    forEach(callback: (value: T, index: number, array: T[]) => void): void;
+}
+export declare const enumOf: <T>(values: T[]) => Enum<T>;
+export type enumOf<E> = E extends Enum<infer T> ? T : never;
+export type EnumType<E> = E extends Enum<infer T> ? T : never;
+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 version = "0.9.0";
+export declare const logo = "\n     _    _                  _     \n    / \\  | | ____ _ _ __    (_)___ \n   / _ \\ | |/ / _' | '_ \\   | / __|\n  / ___ \\|   < (_| | | | |_ | \\__ \\\n /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/\n                          |__/      ver 0.9.0\n? See more details on docs  https://www.akanjs.com/docs\n\u2605 Star Akanjs on GitHub     https://github.com/aka-bassman/akanjs\n\n";

package/src/baseEnv.d.ts

@@ -0,0 +1,48 @@
+import type { SshOptions } from "tunnel-ssh";
+export type Environment = "testing" | "debug" | "develop" | "main";
+export interface BaseEnv {
+    repoName: string;
+    serveDomain: string;
+    appName: string;
+    environment: Environment;
+    operationType: "server" | "client";
+    operationMode: "local" | "edge" | "cloud" | "module";
+    networkType: "mainnet" | "testnet" | "debugnet";
+    tunnelUsername: string;
+    tunnelPassword: string;
+}
+export type BackendEnv = BaseEnv & {
+    hostname: string | null;
+    appCode: number;
+    mongo: {
+        username?: string;
+        password?: string;
+        sshOptions?: SshOptions;
+    };
+    redis?: {
+        sshOptions?: SshOptions;
+    };
+    port?: number;
+    mongoUri?: string;
+    redisUri?: string;
+    meiliUri?: string;
+    onCleanup?: () => Promise<void>;
+};
+export declare const baseEnv: BaseEnv;
+export type BaseClientEnv = 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;
+    serverGraphqlUri: string;
+    serverWsProtocol: "ws:" | "wss:";
+    serverWsUri: string;
+};
+export declare const baseClientEnv: BaseClientEnv;

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./base";
+export * from "./baseEnv";
+export * from "./scalar";
+export * from "./types";

package/src/scalar.d.ts

@@ -0,0 +1,46 @@
+import dayjsLib, { Dayjs } from "dayjs";
+import type { ReadStream } from "fs";
+import type { Readable } from "stream";
+import type { GraphQLJSON, GraphQLUpload, Type } from "./types";
+export { Dayjs };
+export declare const dayjs: typeof dayjsLib;
+export declare class BaseObject {
+    id: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+}
+export declare class Int {
+    __Scalar__: "int";
+}
+export declare class Upload {
+    __Scalar__: "upload";
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    createReadStream: () => ReadStream | Readable;
+}
+export declare class Float {
+    __Scalar__: "float";
+}
+export declare class ID {
+    __Scalar__: "id";
+}
+export declare class JSON {
+    __Scalar__: "json";
+}
+export type SingleFieldType = Int | Float | StringConstructor | BooleanConstructor | ID | DateConstructor | JSON | Type | GraphQLJSON | GraphQLUpload;
+export declare const getNonArrayModel: <T = Type>(arraiedModel: T | T[]) => [T, number];
+export declare const arraiedModel: <T = any>(modelRef: T, arrDepth?: number) => T | T[];
+export declare const applyFnToArrayObjects: (arraiedData: any, fn: (arg: any) => any) => any[];
+export declare const gqlScalars: readonly [StringConstructor, BooleanConstructor, DateConstructor, typeof ID, typeof Int, typeof Float, typeof Upload, typeof JSON, MapConstructor];
+export type GqlScalar = (typeof gqlScalars)[number];
+export declare const gqlScalarNames: readonly ["ID", "Int", "Float", "String", "Boolean", "Date", "Upload", "JSON", "Map"];
+export type GqlScalarName = (typeof gqlScalarNames)[number];
+export declare const scalarSet: Set<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor>;
+export declare const scalarNameMap: Map<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor, "ID" | "Int" | "Float" | "String" | "Boolean" | "Date" | "Upload" | "JSON" | "Map">;
+export declare const scalarArgMap: Map<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor, any>;
+export declare const scalarDefaultMap: Map<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor, any>;
+export declare const isGqlClass: (modelRef: Type) => boolean;
+export declare const isGqlScalar: (modelRef: Type) => boolean;
+export declare const isGqlMap: (modelRef: any) => boolean;

package/src/types.d.ts

@@ -0,0 +1,40 @@
+export type { SshOptions } from "tunnel-ssh";
+export type Type<T = any> = new (...args: any[]) => T;
+export type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[];
+export type GetObject<T> = Omit<{
+    [K in keyof T]: T[K];
+}, "prototype">;
+export type OptionOf<Obj> = {
+    [K in keyof Obj]?: Obj[K] | null;
+};
+export type UnType<T> = T extends new (...args: any) => infer U ? U : never;
+export interface GraphQLUpload {
+    name: string;
+    description: string;
+    specifiedByUrl: string;
+    serialize: any;
+    parseValue: any;
+    parseLiteral: any;
+    extensions: any;
+    astNode: any;
+    extensionASTNodes: any;
+    toConfig(): any;
+    toString(): string;
+    toJSON(): string;
+    inspect(): string;
+}
+export interface GraphQLJSON<TInternal = unknown, TExternal = TInternal> {
+    name: string;
+    description: string;
+    specifiedByURL: string;
+    serialize: any;
+    parseValue: any;
+    parseLiteral: any;
+    extensions: any;
+    astNode: any;
+    extensionASTNodes: any;
+    get [Symbol.toStringTag](): string;
+    toConfig(): any;
+    toString(): string;
+    toJSON(): string;
+}