@wabot-dev/framework 0.0.16 → 0.0.50

package/dist/src/node_modules/selderee/lib/selderee.js

@@ -0,0 +1,380 @@
+import { parse1, normalize, compareSpecificity, serialize } from '../../parseley/lib/parseley.js';
+
+class DecisionTree {
+    constructor(input) {
+        this.branches = weave(toAstTerminalPairs(input));
+    }
+    build(builder) {
+        return builder(this.branches);
+    }
+}
+function toAstTerminalPairs(array) {
+    const len = array.length;
+    const results = new Array(len);
+    for (let i = 0; i < len; i++) {
+        const [selectorString, val] = array[i];
+        const ast = preprocess(parse1(selectorString));
+        results[i] = {
+            ast: ast,
+            terminal: {
+                type: 'terminal',
+                valueContainer: { index: i, value: val, specificity: ast.specificity }
+            }
+        };
+    }
+    return results;
+}
+function preprocess(ast) {
+    reduceSelectorVariants(ast);
+    normalize(ast);
+    return ast;
+}
+function reduceSelectorVariants(ast) {
+    const newList = [];
+    ast.list.forEach(sel => {
+        switch (sel.type) {
+            case 'class':
+                newList.push({
+                    matcher: '~=',
+                    modifier: null,
+                    name: 'class',
+                    namespace: null,
+                    specificity: sel.specificity,
+                    type: 'attrValue',
+                    value: sel.name,
+                });
+                break;
+            case 'id':
+                newList.push({
+                    matcher: '=',
+                    modifier: null,
+                    name: 'id',
+                    namespace: null,
+                    specificity: sel.specificity,
+                    type: 'attrValue',
+                    value: sel.name,
+                });
+                break;
+            case 'combinator':
+                reduceSelectorVariants(sel.left);
+                newList.push(sel);
+                break;
+            case 'universal':
+                break;
+            default:
+                newList.push(sel);
+                break;
+        }
+    });
+    ast.list = newList;
+}
+function weave(items) {
+    const branches = [];
+    while (items.length) {
+        const topKind = findTopKey(items, (sel) => true, getSelectorKind);
+        const { matches, nonmatches, empty } = breakByKind(items, topKind);
+        items = nonmatches;
+        if (matches.length) {
+            branches.push(branchOfKind(topKind, matches));
+        }
+        if (empty.length) {
+            branches.push(...terminate(empty));
+        }
+    }
+    return branches;
+}
+function terminate(items) {
+    const results = [];
+    for (const item of items) {
+        const terminal = item.terminal;
+        if (terminal.type === 'terminal') {
+            results.push(terminal);
+        }
+        else {
+            const { matches, rest } = partition(terminal.cont, (node) => node.type === 'terminal');
+            matches.forEach((node) => results.push(node));
+            if (rest.length) {
+                terminal.cont = rest;
+                results.push(terminal);
+            }
+        }
+    }
+    return results;
+}
+function breakByKind(items, selectedKind) {
+    const matches = [];
+    const nonmatches = [];
+    const empty = [];
+    for (const item of items) {
+        const simpsels = item.ast.list;
+        if (simpsels.length) {
+            const isMatch = simpsels.some(node => getSelectorKind(node) === selectedKind);
+            (isMatch ? matches : nonmatches).push(item);
+        }
+        else {
+            empty.push(item);
+        }
+    }
+    return { matches, nonmatches, empty };
+}
+function getSelectorKind(sel) {
+    switch (sel.type) {
+        case 'attrPresence':
+            return `attrPresence ${sel.name}`;
+        case 'attrValue':
+            return `attrValue ${sel.name}`;
+        case 'combinator':
+            return `combinator ${sel.combinator}`;
+        default:
+            return sel.type;
+    }
+}
+function branchOfKind(kind, items) {
+    if (kind === 'tag') {
+        return tagNameBranch(items);
+    }
+    if (kind.startsWith('attrValue ')) {
+        return attrValueBranch(kind.substring(10), items);
+    }
+    if (kind.startsWith('attrPresence ')) {
+        return attrPresenceBranch(kind.substring(13), items);
+    }
+    if (kind === 'combinator >') {
+        return combinatorBranch('>', items);
+    }
+    if (kind === 'combinator +') {
+        return combinatorBranch('+', items);
+    }
+    throw new Error(`Unsupported selector kind: ${kind}`);
+}
+function tagNameBranch(items) {
+    const groups = spliceAndGroup(items, (x) => x.type === 'tag', (x) => x.name);
+    const variants = Object.entries(groups).map(([name, group]) => ({
+        type: 'variant',
+        value: name,
+        cont: weave(group.items)
+    }));
+    return {
+        type: 'tagName',
+        variants: variants
+    };
+}
+function attrPresenceBranch(name, items) {
+    for (const item of items) {
+        spliceSimpleSelector(item, (x) => (x.type === 'attrPresence') && (x.name === name));
+    }
+    return {
+        type: 'attrPresence',
+        name: name,
+        cont: weave(items)
+    };
+}
+function attrValueBranch(name, items) {
+    const groups = spliceAndGroup(items, (x) => (x.type === 'attrValue') && (x.name === name), (x) => `${x.matcher} ${x.modifier || ''} ${x.value}`);
+    const matchers = [];
+    for (const group of Object.values(groups)) {
+        const sel = group.oneSimpleSelector;
+        const predicate = getAttrPredicate(sel);
+        const continuation = weave(group.items);
+        matchers.push({
+            type: 'matcher',
+            matcher: sel.matcher,
+            modifier: sel.modifier,
+            value: sel.value,
+            predicate: predicate,
+            cont: continuation
+        });
+    }
+    return {
+        type: 'attrValue',
+        name: name,
+        matchers: matchers
+    };
+}
+function getAttrPredicate(sel) {
+    if (sel.modifier === 'i') {
+        const expected = sel.value.toLowerCase();
+        switch (sel.matcher) {
+            case '=':
+                return (actual) => expected === actual.toLowerCase();
+            case '~=':
+                return (actual) => actual.toLowerCase().split(/[ \t]+/).includes(expected);
+            case '^=':
+                return (actual) => actual.toLowerCase().startsWith(expected);
+            case '$=':
+                return (actual) => actual.toLowerCase().endsWith(expected);
+            case '*=':
+                return (actual) => actual.toLowerCase().includes(expected);
+            case '|=':
+                return (actual) => {
+                    const lower = actual.toLowerCase();
+                    return (expected === lower) || (lower.startsWith(expected) && lower[expected.length] === '-');
+                };
+        }
+    }
+    else {
+        const expected = sel.value;
+        switch (sel.matcher) {
+            case '=':
+                return (actual) => expected === actual;
+            case '~=':
+                return (actual) => actual.split(/[ \t]+/).includes(expected);
+            case '^=':
+                return (actual) => actual.startsWith(expected);
+            case '$=':
+                return (actual) => actual.endsWith(expected);
+            case '*=':
+                return (actual) => actual.includes(expected);
+            case '|=':
+                return (actual) => (expected === actual) || (actual.startsWith(expected) && actual[expected.length] === '-');
+        }
+    }
+}
+function combinatorBranch(combinator, items) {
+    const groups = spliceAndGroup(items, (x) => (x.type === 'combinator') && (x.combinator === combinator), (x) => serialize(x.left));
+    const leftItems = [];
+    for (const group of Object.values(groups)) {
+        const rightCont = weave(group.items);
+        const leftAst = group.oneSimpleSelector.left;
+        leftItems.push({
+            ast: leftAst,
+            terminal: { type: 'popElement', cont: rightCont }
+        });
+    }
+    return {
+        type: 'pushElement',
+        combinator: combinator,
+        cont: weave(leftItems)
+    };
+}
+function spliceAndGroup(items, predicate, keyCallback) {
+    const groups = {};
+    while (items.length) {
+        const bestKey = findTopKey(items, predicate, keyCallback);
+        const bestKeyPredicate = (sel) => predicate(sel) && keyCallback(sel) === bestKey;
+        const hasBestKeyPredicate = (item) => item.ast.list.some(bestKeyPredicate);
+        const { matches, rest } = partition1(items, hasBestKeyPredicate);
+        let oneSimpleSelector = null;
+        for (const item of matches) {
+            const splicedNode = spliceSimpleSelector(item, bestKeyPredicate);
+            if (!oneSimpleSelector) {
+                oneSimpleSelector = splicedNode;
+            }
+        }
+        if (oneSimpleSelector == null) {
+            throw new Error('No simple selector is found.');
+        }
+        groups[bestKey] = { oneSimpleSelector: oneSimpleSelector, items: matches };
+        items = rest;
+    }
+    return groups;
+}
+function spliceSimpleSelector(item, predicate) {
+    const simpsels = item.ast.list;
+    const matches = new Array(simpsels.length);
+    let firstIndex = -1;
+    for (let i = simpsels.length; i-- > 0;) {
+        if (predicate(simpsels[i])) {
+            matches[i] = true;
+            firstIndex = i;
+        }
+    }
+    if (firstIndex == -1) {
+        throw new Error(`Couldn't find the required simple selector.`);
+    }
+    const result = simpsels[firstIndex];
+    item.ast.list = simpsels.filter((sel, i) => !matches[i]);
+    return result;
+}
+function findTopKey(items, predicate, keyCallback) {
+    const candidates = {};
+    for (const item of items) {
+        const candidates1 = {};
+        for (const node of item.ast.list.filter(predicate)) {
+            candidates1[keyCallback(node)] = true;
+        }
+        for (const key of Object.keys(candidates1)) {
+            if (candidates[key]) {
+                candidates[key]++;
+            }
+            else {
+                candidates[key] = 1;
+            }
+        }
+    }
+    let topKind = '';
+    let topCounter = 0;
+    for (const entry of Object.entries(candidates)) {
+        if (entry[1] > topCounter) {
+            topKind = entry[0];
+            topCounter = entry[1];
+        }
+    }
+    return topKind;
+}
+function partition(src, predicate) {
+    const matches = [];
+    const rest = [];
+    for (const x of src) {
+        if (predicate(x)) {
+            matches.push(x);
+        }
+        else {
+            rest.push(x);
+        }
+    }
+    return { matches, rest };
+}
+function partition1(src, predicate) {
+    const matches = [];
+    const rest = [];
+    for (const x of src) {
+        if (predicate(x)) {
+            matches.push(x);
+        }
+        else {
+            rest.push(x);
+        }
+    }
+    return { matches, rest };
+}
+
+class Picker {
+    constructor(f) {
+        this.f = f;
+    }
+    pickAll(el) {
+        return this.f(el);
+    }
+    pick1(el, preferFirst = false) {
+        const results = this.f(el);
+        const len = results.length;
+        if (len === 0) {
+            return null;
+        }
+        if (len === 1) {
+            return results[0].value;
+        }
+        const comparator = (preferFirst)
+            ? comparatorPreferFirst
+            : comparatorPreferLast;
+        let result = results[0];
+        for (let i = 1; i < len; i++) {
+            const next = results[i];
+            if (comparator(result, next)) {
+                result = next;
+            }
+        }
+        return result.value;
+    }
+}
+function comparatorPreferFirst(acc, next) {
+    const diff = compareSpecificity(next.specificity, acc.specificity);
+    return diff > 0 || (diff === 0 && next.index < acc.index);
+}
+function comparatorPreferLast(acc, next) {
+    const diff = compareSpecificity(next.specificity, acc.specificity);
+    return diff > 0 || (diff === 0 && next.index > acc.index);
+}
+
+export { DecisionTree, Picker };

package/dist/src/pre-made/module/authentication/requests/SendOneTimePasswordRequest.js

@@ -2,8 +2,6 @@ import { __decorate, __metadata } from 'tslib';
 import 'reflect-metadata';
 import '../../../../injection/index.js';
 import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import '../../../../core/chat/repository/IChatRepository.js';
-import '../../../../core/user/IUserRepository.js';
 import { param } from '../../../../mindset/metadata/params/@param.js';
 import '../../../../mindset/MindsetOperator.js';
 

package/dist/src/pre-made/module/authentication/requests/ValidateOneTimePasswordRequest.js

@@ -2,8 +2,6 @@ import { __decorate, __metadata } from 'tslib';
 import 'reflect-metadata';
 import '../../../../injection/index.js';
 import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import '../../../../core/chat/repository/IChatRepository.js';
-import '../../../../core/user/IUserRepository.js';
 import { param } from '../../../../mindset/metadata/params/@param.js';
 import '../../../../mindset/MindsetOperator.js';
 

package/dist/src/pre-made/module/html/HtmlModule.js

@@ -0,0 +1,70 @@
+import { __decorate, __metadata } from 'tslib';
+import { mindsetFunction } from '../../../mindset/metadata/functions/@mindsetFunction.js';
+import 'reflect-metadata';
+import '../../../injection/index.js';
+import '../../../mindset/metadata/MindsetMetadataStore.js';
+import { mindsetModule } from '../../../mindset/metadata/modules/@mindsetModule.js';
+import { param } from '../../../mindset/metadata/params/@param.js';
+import '../../../mindset/MindsetOperator.js';
+import { convert } from '../../../node_modules/html-to-text/lib/html-to-text.js';
+
+function toPascalCaseFunctionName(title) {
+    const cleaned = title.replace(/[^a-zA-Z0-9]+/g, ' ');
+    const words = cleaned
+        .trim()
+        .split(/\s+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+    return words.join('');
+}
+async function fetchRawHtml(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        const html = await response.text();
+        return html;
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch HTML from ${url}: ${error.message}`);
+    }
+}
+class KeywordsReq {
+    keywords = '';
+}
+__decorate([
+    param({
+        description: 'Keywords separated by space',
+    }),
+    __metadata("design:type", String)
+], KeywordsReq.prototype, "keywords", void 0);
+function HtmlModule(options) {
+    var _a;
+    const standaricedTitle = toPascalCaseFunctionName(options.title);
+    let documentText = null;
+    let HtmlModuleIntern = class HtmlModuleIntern {
+        async [_a = `searchInTheDocument${standaricedTitle}`](req) {
+            if (!documentText) {
+                const rawHtml = await fetchRawHtml(options.url);
+                documentText = convert(rawHtml);
+            }
+            return documentText;
+        }
+    };
+    __decorate([
+        mindsetFunction({
+            description: `Search information using keywords in the document "${options.title}". Priorize this info.`,
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [KeywordsReq]),
+        __metadata("design:returntype", Promise)
+    ], HtmlModuleIntern.prototype, _a, null);
+    HtmlModuleIntern = __decorate([
+        mindsetModule({
+            description: `Search information using keywords in the document ${options.title}`,
+        })
+    ], HtmlModuleIntern);
+    return HtmlModuleIntern;
+}
+
+export { HtmlModule };

package/dist/src/pre-made/module/register-user/requests/RegisterUserWithEmailRequest.js

@@ -2,8 +2,6 @@ import { __decorate, __metadata } from 'tslib';
 import 'reflect-metadata';
 import '../../../../injection/index.js';
 import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import '../../../../core/chat/repository/IChatRepository.js';
-import '../../../../core/user/IUserRepository.js';
 import { param } from '../../../../mindset/metadata/params/@param.js';
 import '../../../../mindset/MindsetOperator.js';
 

package/dist/src/pre-made/repository/chat/pg/PgChatMemory.js

@@ -1,13 +1,7 @@
-import { ChatItem } from '../../../../core/chat/ChatItem.js';
 import '../../../../core/chat/repository/IChatRepository.js';
+import { ChatItem } from '../../../../core/chat/ChatItem.js';
 import '../../../../core/user/IUserRepository.js';
 import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
-import 'fs';
-import 'path';
-import 'sqlite';
-import 'sqlite3';
-import 'uuid';
-import 'pg';
 
 class PgChatMemory extends PgCrudRepository {
     chatId;

package/dist/src/pre-made/repository/chat/pg/PgChatRepository.js

@@ -6,11 +6,6 @@ import { singleton } from '../../../../injection/index.js';
 import { Pool } from 'pg';
 import { PgChatMemory } from './PgChatMemory.js';
 import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
-import 'fs';
-import 'path';
-import 'sqlite';
-import 'sqlite3';
-import 'uuid';
 
 let PgChatRepository = class PgChatRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/pre-made/repository/user/pg/PgUserRepository.js

@@ -4,11 +4,6 @@ import { User } from '../../../../core/user/User.js';
 import '../../../../core/user/IUserRepository.js';
 import { singleton } from '../../../../injection/index.js';
 import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
-import 'fs';
-import 'path';
-import 'sqlite';
-import 'sqlite3';
-import 'uuid';
 import { Pool } from 'pg';
 
 let PgUserRepository = class PgUserRepository extends PgCrudRepository {

package/dist/src/repository/pg/PgCrudRepository.js

@@ -1,4 +1,3 @@
-import 'pg';
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
 

package/dist/src/rest-controller/metadata/@get.js

@@ -0,0 +1,19 @@
+import { container } from '../../injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function get(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveEndPointMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            method: 'get',
+            path: config?.path,
+            paramsTypes,
+        });
+    };
+}
+
+export { get };

package/dist/src/rest-controller/metadata/@post.js

@@ -0,0 +1,19 @@
+import { container } from '../../injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function post(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveEndPointMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            method: 'post',
+            path: config?.path,
+            paramsTypes,
+        });
+    };
+}
+
+export { post };

package/dist/src/rest-controller/metadata/@restController.js

@@ -0,0 +1,15 @@
+import { container, injectable } from '../../injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function restController(config) {
+    return function (target) {
+        const metaDataStore = container.resolve(RestControllerMetadataStore);
+        metaDataStore.saveControllerMetadata({
+            controllerConstructor: target,
+            path: config.path,
+        });
+        injectable()(target);
+    };
+}
+
+export { restController };

package/dist/src/rest-controller/metadata/RestControllerMetadataStore.js

@@ -0,0 +1,37 @@
+import { __decorate } from 'tslib';
+import { singleton } from 'tsyringe';
+
+let RestControllerMetadataStore = class RestControllerMetadataStore {
+    endPoints = new Map();
+    restControllers = new Map();
+    saveControllerMetadata(controllerMetadata) {
+        this.restControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
+    }
+    saveEndPointMetadata(endPointMetadata) {
+        let controllerEndPoints = this.endPoints.get(endPointMetadata.controllerConstructor);
+        if (!controllerEndPoints) {
+            this.endPoints.set(endPointMetadata.controllerConstructor, (controllerEndPoints = new Map()));
+        }
+        controllerEndPoints.set(endPointMetadata.functionName, endPointMetadata);
+    }
+    getControllerEndPointsInfo(controllerConstructor) {
+        const controller = this.restControllers.get(controllerConstructor);
+        if (!controller) {
+            throw new Error(`${controllerConstructor.name} should be decorated with @restController`);
+        }
+        const endPoints = this.endPoints.get(controllerConstructor);
+        if (!endPoints?.size) {
+            // TODO: Warning
+            return [];
+        }
+        return [...endPoints.values()].map((endPoint) => ({
+            ...endPoint,
+            controller: this.restControllers.get(endPoint.controllerConstructor),
+        }));
+    }
+};
+RestControllerMetadataStore = __decorate([
+    singleton()
+], RestControllerMetadataStore);
+
+export { RestControllerMetadataStore };