kodo-core 0.1.0 → 0.1.1

package/dist/_enums.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/expressions/_defines.d.ts

@@ -0,0 +1,7 @@
+export declare type LinkOperator = ">=" | ">" | "<" | "<=" | "==" | "!=" | "->";
+export declare type ROperator_Atom = ">=" | ">" | "<" | "<=" | "==" | "===" | "!=" | "!==";
+export declare type ROperator_Array = "IN" | "!IN";
+export declare type ROperator = ROperator_Atom | ROperator_Array;
+export declare type BOperator = "&&" | "||";
+export declare function revertLinkOperator(op: LinkOperator): LinkOperator | null;
+export declare function convertLP2RO(op: LinkOperator): ROperator | null;

package/dist/expressions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./_defines";
+export * from "./linkExpression";
+export * from "./queryExpression";

package/dist/expressions/linkExpression.d.ts

@@ -0,0 +1,13 @@
+import { BOperator, LinkOperator } from "./_defines";
+export type LinkOn<TFrom, TTo> = {
+    $from?: keyof TFrom;
+    $op?: LinkOperator;
+    $to?: keyof TTo;
+};
+export type LinkExpressionWhere<TFrom, TTo> = {
+    $with?: BOperator;
+    $where?: Array<LinkExpression<TFrom, TTo>>;
+};
+export type LinkExpressionObject<TFrom, TTo> = LinkExpressionWhere<TFrom, TTo> & LinkOn<TFrom, TTo>;
+export type LinkExpression<TFrom, TTo> = LinkExpressionObject<TFrom, TTo>;
+export declare function isLinkExpressionKey(key: string): boolean;

package/dist/expressions/queryExpression.d.ts

@@ -0,0 +1,21 @@
+import { BOperator, ROperator_Atom, ROperator_Array } from "./_defines";
+export type QueryOnAtomValue<T, P extends keyof T> = {
+    $op?: ROperator_Atom;
+    $val: T[P] | null | undefined;
+};
+export type QueryOnArrayValue<T, P extends keyof T> = {
+    $op?: ROperator_Array;
+    $val: T[P][];
+};
+export type QueryOnValue<T, P extends keyof T> = QueryOnAtomValue<T, P> | QueryOnArrayValue<T, P>;
+export type QueryOn<T> = {
+    [P in keyof T]?: QueryOnValue<T, P> | T[P];
+};
+export type QueryExpressionWhere<T> = {
+    $with?: BOperator;
+    $where?: Array<QueryExpression<T>>;
+};
+export type QueryExpressionPredicate<T> = (item: T) => boolean;
+export type QueryExpressionObject<T> = QueryExpressionWhere<T> & QueryOn<T>;
+export type QueryExpression<T> = QueryExpressionObject<T> | QueryExpressionPredicate<T>;
+export declare function isQueryExpressionKey(key: string): boolean;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./providers";
+export * from "./kodo";
+export * from "./nodes/";
+export * from "./expressions";
+export * from "./translators";
+export * from "./utils";

package/dist/kodo.d.ts

@@ -0,0 +1,25 @@
+import { DataNode, DataNodeMap, QueryNode } from "./nodes";
+import { IDataProvider } from "./providers";
+import { INodeTranslator } from "./translators";
+export interface ExploreOption {
+    tierLimit: number;
+}
+export interface KodoOption extends ExploreOption {
+    cache: boolean;
+    recursion: boolean;
+}
+export declare class Kodo {
+    protected name: string;
+    translators: INodeTranslator[];
+    providers: IDataProvider[];
+    nodes: DataNodeMap;
+    opt: KodoOption;
+    private getDefaultOption;
+    constructor(name: string, opt?: Partial<KodoOption>);
+    setOption(opt: Partial<KodoOption>): void;
+    linkExpression(expression: string, params?: string[]): void;
+    registerTranslator(translator: INodeTranslator): void;
+    registerProvider(provider: IDataProvider): void;
+    private loopExplore;
+    explore<T>(startup: QueryNode<T>): DataNode<any>[];
+}

package/dist/nodes/dataNode.d.ts

@@ -0,0 +1,15 @@
+import { NodeBase } from "./nodeBase";
+import { QueryNode } from "./queryNode";
+export declare class DataNode<T> extends NodeBase {
+    $fromQN?: QueryNode<T>;
+    data: Partial<T>;
+}
+export declare class DataNodeMap {
+    nodes: Map<string, DataNode<any>>;
+    ns: Map<string, DataNode<any>[]>;
+    constructor();
+    tryAdd<T>(node: DataNode<T>): boolean;
+    getList(): DataNode<any>[];
+    clear(): void;
+    existNS(ns: string): boolean;
+}

package/dist/nodes/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./nodeBase";
+export * from "./dataNode";
+export * from "./queryNode";
+export * from "./linkNode";

package/dist/nodes/linkNode.d.ts

@@ -0,0 +1,10 @@
+import { LinkExpression } from "../expressions";
+import { NodeBase } from "./nodeBase";
+export declare class LinkNode<TFrom, TTo> extends NodeBase {
+    $fromNS: string;
+    $toNS: string;
+    protected $type?: null | undefined | "R";
+    expression: LinkExpression<TFrom, TTo>;
+    private static revertExpression;
+    static revert<TFrom, TTo>(node: LinkNode<TFrom, TTo>): LinkNode<TTo, TFrom> | null;
+}

package/dist/nodes/nodeBase.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class NodeBase {
+    $id?: number | string;
+    $ns: string;
+}

package/dist/nodes/queryNode.d.ts

@@ -0,0 +1,9 @@
+import { QueryExpression } from "../expressions/queryExpression";
+import { DataNode } from "./dataNode";
+import { LinkNode } from "./linkNode";
+import { NodeBase } from "./nodeBase";
+export declare class QueryNode<T> extends NodeBase {
+    $fromDN?: DataNode<any>;
+    $fromLN?: LinkNode<any, T>;
+    expression: QueryExpression<T>;
+}

package/dist/providers/iDataProvider.d.ts

@@ -0,0 +1,4 @@
+import { DataNode, QueryNode } from "../nodes";
+export interface IDataProvider {
+    lookup<T>(node: QueryNode<T>): DataNode<any>[];
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./iDataProvider";
+export * from "./memoryProvider";

package/dist/providers/memoryProvider.d.ts

@@ -0,0 +1,19 @@
+import { DataNode } from "../nodes";
+import { QueryNode } from "../nodes/queryNode";
+import { IDataProvider } from "./iDataProvider";
+export declare class MemoryData<T> {
+    ns: string;
+    val: T;
+}
+export declare class MemoryProvider implements IDataProvider {
+    private objs;
+    constructor();
+    add<T>(namespace: string, obj: T): void;
+    private copmareNull;
+    private isMatchData;
+    private assumeMatchList;
+    private isAllMatchWith;
+    private matchOnData;
+    private match;
+    lookup<T>(qNode: QueryNode<T>): DataNode<any>[];
+}

package/dist/translators/iNodeTranslator.d.ts

@@ -0,0 +1,7 @@
+import { DataNode, LinkNode, QueryNode } from "../nodes";
+export interface INodeTranslator {
+    all(): LinkNode<any, any>[];
+    link<TFrom, TTo>(ln: LinkNode<TFrom, TTo>): boolean;
+    match<TFrom>(dn: DataNode<TFrom>): boolean;
+    translate<TFrom, TTo>(data: DataNode<TFrom>): QueryNode<TTo>[];
+}

package/dist/translators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./iNodeTranslator";
+export * from "./nodeTranslator";

package/dist/translators/nodeTranslator.d.ts

@@ -0,0 +1,12 @@
+import { DataNode, LinkNode, QueryNode } from "../nodes";
+import { INodeTranslator } from "./iNodeTranslator";
+export declare class NodeTranslator implements INodeTranslator {
+    private linkNodes;
+    constructor();
+    all(): LinkNode<any, any>[];
+    match<TFrom>(dn: DataNode<TFrom>): boolean;
+    link<TFrom, TTo>(ln: LinkNode<TFrom, TTo>): boolean;
+    private tryMapOnData;
+    private tryMap;
+    translate<TFrom, TTo>(data: DataNode<TFrom>): QueryNode<TTo>[];
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1,3 @@
+export declare function generateHashCode(obj: any, opt?: {
+    seed?: number;
+}): string;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./hash";
+export * from "./objectUtil";

package/dist/utils/objectUtil.d.ts

@@ -0,0 +1 @@
+export declare function isNullOrUndefined(obj: any): boolean;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "kodo-core",
-  "version": "0.1.0",
-  "main": "dist/kodo-core.min.js",
-  "types": "./dist/index.d.ts",
+  "version": "0.1.1",
+  "author": "Shadow Lei",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "repository": "git@github.com:ShadowLei/kodo-core.git",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -15,7 +16,9 @@
   ],
   "scripts": {
     "build-dev": "bun build ./src/index.ts --outdir ./dist",
-    "build": "bun build --production ./src/index.ts --outdir ./dist",
+    "build:js": "bun build --production ./src/index.ts --outdir ./dist",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build": "bun run build:js && bun run build:types",
     "test": "bun test ./test/*.test.ts"
   },
   "keywords": [