teledzik 1.0.3 → 1.0.5

package/src/session.js

@@ -1,175 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSessionContext = exports.MemorySessionStore = exports.session = void 0;
-const debug_1 = __importDefault(require("debug"));
-const debug = (0, debug_1.default)('telegraf:session');
-/**
- * Returns middleware that adds `ctx.session` for storing arbitrary state per session key.
- *
- * The default `getSessionKey` is `${ctx.from.id}:${ctx.chat.id}`.
- * If either `ctx.from` or `ctx.chat` is `undefined`, default session key and thus `ctx.session` are also `undefined`.
- *
- * > ⚠️ Session data is kept only in memory by default,  which means that all data will be lost when the process is terminated.
- * >
- * > If you want to persist data across process restarts, or share it among multiple instances, you should use
- * [@telegraf/session](https://www.npmjs.com/package/@telegraf/session), or pass custom `storage`.
- *
- * @see {@link https://github.com/feathers-studio/telegraf-docs/blob/b694bcc36b4f71fb1cd650a345c2009ab4d2a2a5/guide/session.md Telegraf Docs | Session}
- * @see {@link https://github.com/feathers-studio/telegraf-docs/blob/master/examples/session-bot.ts Example}
- */
-function session(options) {
-    var _a, _b, _c;
-    const prop = (_a = options === null || options === void 0 ? void 0 : options.property) !== null && _a !== void 0 ? _a : 'session';
-    const getSessionKey = (_b = options === null || options === void 0 ? void 0 : options.getSessionKey) !== null && _b !== void 0 ? _b : defaultGetSessionKey;
-    const store = (_c = options === null || options === void 0 ? void 0 : options.store) !== null && _c !== void 0 ? _c : new MemorySessionStore();
-    // caches value from store in-memory while simultaneous updates share it
-    // when counter reaches 0, the cached ref will be freed from memory
-    const cache = new Map();
-    // temporarily stores concurrent requests
-    const concurrents = new Map();
-    // this function must be handled with care
-    // read full description on the original PR: https://github.com/telegraf/telegraf/pull/1713
-    // make sure to update the tests in test/session.js if you make any changes or fix bugs here
-    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-        var _d;
-        const updId = ctx.update.update_id;
-        let released = false;
-        function releaseChecks() {
-            if (released && process.env.EXPERIMENTAL_SESSION_CHECKS)
-                throw new Error("Session was accessed or assigned to after the middleware chain exhausted. This is a bug in your code. You're probably accessing session asynchronously and missing awaits.");
-        }
-        // because this is async, requests may still race here, but it will get autocorrected at (1)
-        // v5 getSessionKey should probably be synchronous to avoid that
-        const key = yield getSessionKey(ctx);
-        if (!key) {
-            // Leaving this here could be useful to check for `prop in ctx` in future middleware
-            ctx[prop] = undefined;
-            return yield next();
-        }
-        let cached = cache.get(key);
-        if (cached) {
-            debug(`(${updId}) found cached session, reusing from cache`);
-            ++cached.counter;
-        }
-        else {
-            debug(`(${updId}) did not find cached session`);
-            // if another concurrent request has already sent a store request, fetch that instead
-            let promise = concurrents.get(key);
-            if (promise)
-                debug(`(${updId}) found a concurrent request, reusing promise`);
-            else {
-                debug(`(${updId}) fetching from upstream store`);
-                promise = store.get(key);
-            }
-            // synchronously store promise so concurrent requests can share response
-            concurrents.set(key, promise);
-            const upstream = yield promise;
-            // all concurrent awaits will have promise in their closure, safe to remove now
-            concurrents.delete(key);
-            debug(`(${updId}) updating cache`);
-            // another request may have beaten us to the punch
-            const c = cache.get(key);
-            if (c) {
-                // another request did beat us to the punch
-                c.counter++;
-                // (1) preserve cached reference; in-memory reference is always newer than from store
-                cached = c;
-            }
-            else {
-                // we're the first, so we must cache the reference
-                cached = { ref: upstream !== null && upstream !== void 0 ? upstream : (_d = options === null || options === void 0 ? void 0 : options.defaultSession) === null || _d === void 0 ? void 0 : _d.call(options, ctx), counter: 1 };
-                cache.set(key, cached);
-            }
-        }
-        // TS already knows cached is always defined by this point, but does not guard cached.
-        // It will, however, guard `c` here.
-        const c = cached;
-        let touched = false;
-        Object.defineProperty(ctx, prop, {
-            get() {
-                releaseChecks();
-                touched = true;
-                return c.ref;
-            },
-            set(value) {
-                releaseChecks();
-                touched = true;
-                c.ref = value;
-            },
-        });
-        try {
-            yield next();
-            released = true;
-        }
-        finally {
-            if (--c.counter === 0) {
-                // decrement to avoid memory leak
-                debug(`(${updId}) refcounter reached 0, removing cached`);
-                cache.delete(key);
-            }
-            debug(`(${updId}) middlewares completed, checking session`);
-            // only update store if ctx.session was touched
-            if (touched)
-                if (c.ref == null) {
-                    debug(`(${updId}) ctx.${prop} missing, removing from store`);
-                    yield store.delete(key);
-                }
-                else {
-                    debug(`(${updId}) ctx.${prop} found, updating store`);
-                    yield store.set(key, c.ref);
-                }
-        }
-    });
-}
-exports.session = session;
-function defaultGetSessionKey(ctx) {
-    var _a, _b;
-    const fromId = (_a = ctx.from) === null || _a === void 0 ? void 0 : _a.id;
-    const chatId = (_b = ctx.chat) === null || _b === void 0 ? void 0 : _b.id;
-    if (fromId == null || chatId == null)
-        return undefined;
-    return `${fromId}:${chatId}`;
-}
-/** @deprecated Use `Map` */
-class MemorySessionStore {
-    constructor(ttl = Infinity) {
-        this.ttl = ttl;
-        this.store = new Map();
-    }
-    get(name) {
-        const entry = this.store.get(name);
-        if (entry == null) {
-            return undefined;
-        }
-        else if (entry.expires < Date.now()) {
-            this.delete(name);
-            return undefined;
-        }
-        return entry.session;
-    }
-    set(name, value) {
-        const now = Date.now();
-        this.store.set(name, { session: value, expires: now + this.ttl });
-    }
-    delete(name) {
-        this.store.delete(name);
-    }
-}
-exports.MemorySessionStore = MemorySessionStore;
-/** @deprecated session can use custom properties now. Directly use `'session' in ctx` instead */
-function isSessionContext(ctx) {
-    return 'session' in ctx;
-}
-exports.isSessionContext = isSessionContext;

package/src/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/src/utils.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.argsParser = void 0;
-var args_1 = require("./core/helpers/args");
-Object.defineProperty(exports, "argsParser", { enumerable: true, get: function () { return args_1.argsParser; } });