koishi-plugin-countdown-clock 1.0.0

package/lib/data/countdowns.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "koishi";
+import { CountDownData, Time } from "../types/countdown";
+export declare function addCountDown(ctx: Context, uid: number, platform: string, channel: string, time: Time, text?: string): Promise<CountDownData>;
+export declare function initCountDown(ctx: Context): Promise<void>;
+export declare function getCountDown(ctx: Context, uid: number): CountDownData;
+export declare function removeCountDown(ctx: Context, countDownOrId: number | CountDownData): Promise<false | import("minato").Driver.WriteResult>;
+export declare function getAllCountDown(): CountDownData[];
+export declare function getAndRemoveTimeUpCountDown(ctx: Context): Promise<CountDownData[]>;

package/lib/data/database.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "koishi";
+export declare function init(ctx: Context): Promise<void>;

package/lib/features/cancel.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "koishi";
+export declare function registerCancelCommand(ctx: Context): void;

package/lib/features/countdown.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "koishi";
+export declare function registerCountDownCommand(ctx: Context): void;

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "countdown";
+export interface Config {
+}
+export declare const Config: Schema<Config>;
+export declare const inject: {
+    required: string[];
+};
+export declare function apply(ctx: Context): void;

package/lib/index.js

@@ -0,0 +1,224 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/locales/zh-CN.yml
+var require_zh_CN = __commonJS({
+  "src/locales/zh-CN.yml"(exports2, module2) {
+    module2.exports = { time: { s: "秒", m: "分钟", h: "小时", d: "天" }, countdown: { timeup: "<at id={uid}/> {text} 时间到", "default-text": "倒计时" }, commands: { countdown: { description: "开始一个倒计时", messages: { countdown: "<at id={uid}/> {text}剩余{time}", "no-countdown": "<at id={uid}/> 当前没有正在运行的倒计时", "time-invalid": "<at id={uid}/> 时间格式错误", "has-countdown": "<at id={uid}/> 当前有倒计时正在运行", success: "<at id={uid}/> {text}将在{time}后提醒你" }, cancel: { description: "取消一个倒计时", messages: { success: "<at id={uid}/> 倒计时已取消", "no-countdown": "<at id={uid}/> 当前没有正在运行的倒计时" } } } } };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+
+// src/utils/time.ts
+var units = ["d", "h", "m", "s"];
+var uTransform = {
+  分钟: "m",
+  分: "m",
+  小时: "h",
+  天: "d",
+  秒: "s",
+  时: "h"
+};
+function getTimeStrSess(session, time) {
+  return units.map((unit) => time[unit] ? time[unit] + session.text(`time.${unit}`) : "").filter((x) => x).join(" ");
+}
+__name(getTimeStrSess, "getTimeStrSess");
+function parseTimeStr(str) {
+  if (!/^(([0-9]+)([hmsdHMSD]|分钟?|小?时|秒|天))+$/ig.test(str))
+    return null;
+  const matches = str.matchAll(/([0-9]+)([hmsdHMSD]|分钟?|小?时|秒|天)/ig);
+  const time = {};
+  for (const match of matches) {
+    let unit = match[2].toLowerCase();
+    if (uTransform[unit])
+      unit = uTransform[unit];
+    if (!units.includes(unit))
+      return null;
+    time[unit] = parseInt(match[1]);
+  }
+  return time;
+}
+__name(parseTimeStr, "parseTimeStr");
+function getTimeAfter(time) {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(now.getTime() + (time.s || 0) * 1e3 + (time.m || 0) * 60 * 1e3 + (time.h || 0) * 60 * 60 * 1e3 + (time.d || 0) * 24 * 60 * 60 * 1e3);
+}
+__name(getTimeAfter, "getTimeAfter");
+function getTimeTo(end) {
+  const now = /* @__PURE__ */ new Date();
+  const delta = end.getTime() - now.getTime();
+  return {
+    s: Math.floor(delta / 1e3 % 60),
+    m: Math.floor(delta / 1e3 / 60 % 60),
+    h: Math.floor(delta / 1e3 / 60 / 60 % 24),
+    d: Math.floor(delta / 1e3 / 60 / 60 / 24)
+  };
+}
+__name(getTimeTo, "getTimeTo");
+
+// src/data/countdowns.ts
+var CountDownStore = [];
+async function addCountDown(ctx, uid, platform, channel, time, text) {
+  text = text || "";
+  const until = getTimeAfter(time);
+  const model = await ctx.model.create("countdown", { uid, platform, channel, until, time, text });
+  CountDownStore.push(model);
+  return model;
+}
+__name(addCountDown, "addCountDown");
+function getCountDown(ctx, uid) {
+  return CountDownStore.find((x) => x.uid === uid);
+}
+__name(getCountDown, "getCountDown");
+async function removeCountDown(ctx, countDownOrId) {
+  const id = typeof countDownOrId === "number" ? countDownOrId : countDownOrId.id;
+  if (!id || !CountDownStore.find((x) => x.id === id))
+    return false;
+  CountDownStore.splice(CountDownStore.findIndex((x) => x.id === id), 1);
+  return await ctx.model.remove("countdown", { id });
+}
+__name(removeCountDown, "removeCountDown");
+async function getAndRemoveTimeUpCountDown(ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const res = CountDownStore.filter((x) => x.until < now);
+  res.forEach((x) => removeCountDown(ctx, x));
+  return res;
+}
+__name(getAndRemoveTimeUpCountDown, "getAndRemoveTimeUpCountDown");
+
+// src/job/checkCountDown.ts
+function registerCheckDown(ctx) {
+  ctx.setInterval(() => check(ctx), 1e3);
+}
+__name(registerCheckDown, "registerCheckDown");
+async function check(ctx) {
+  const removed = await getAndRemoveTimeUpCountDown(ctx);
+  for (const countDown of removed) {
+    sendMessage(ctx, countDown.platform, countDown.channel, countDown.uid.toString(), "countdown.timeup", { uid: countDown.uid, text: countDown.text });
+  }
+}
+__name(check, "check");
+async function sendMessage(ctx, platform, channel, uid, messageKey, param) {
+  const channelCheks = await Promise.all(ctx.bots.filter((t) => t.platform == platform).map((t) => ({
+    ch: t.getChannel(channel),
+    bot: t
+  })));
+  const bot = channelCheks.find((t) => t.ch)?.bot;
+  if (!bot) {
+    return false;
+  }
+  const user = await ctx.database.getUser(platform, uid);
+  const messageTxt = ctx.i18n.render(user.locales, [messageKey], param);
+  bot.sendMessage(channel, messageTxt);
+}
+__name(sendMessage, "sendMessage");
+
+// src/features/countdown.ts
+function registerCountDownCommand(ctx) {
+  ctx.command("countdown [time:string] [text:string]").action(async (args, time, text) => await process(ctx, args.session, time, text));
+}
+__name(registerCountDownCommand, "registerCountDownCommand");
+async function process(ctx, session, _time, text) {
+  const ctd = await getCountDown(ctx, session.userId);
+  if (!_time) {
+    return ctd && ctd.until.getTime() > Date.now() ? session.text(".countdown", { time: getTimeStrSess(session, getTimeTo(ctd.until)), text: ctd.text }) : session.text(".no-countdown");
+  } else if (ctd)
+    return session.text(".has-countdown");
+  text = text || session.text("countdown.default-text");
+  const time = parseTimeStr(_time);
+  if (!time)
+    return session.text(".time-invalid");
+  await addCountDown(ctx, session.userId, session.platform, session.channelId, time, text);
+  return session.text(".success", { time: getTimeStrSess(session, time), text });
+}
+__name(process, "process");
+
+// src/features/cancel.ts
+function registerCancelCommand(ctx) {
+  ctx.command("countdown.cancel").action(async (args) => await process2(ctx, args.session));
+}
+__name(registerCancelCommand, "registerCancelCommand");
+async function process2(ctx, session) {
+  const ctd = await getCountDown(ctx, session.userId);
+  if (!ctd)
+    return session.text(".no-countdown");
+  await removeCountDown(ctx, ctd);
+  return session.text(".success");
+}
+__name(process2, "process");
+
+// src/reg.ts
+var T = [
+  registerCheckDown,
+  registerCountDownCommand,
+  registerCancelCommand
+];
+function registerAll(ctx) {
+  return Promise.all(T.map((t) => t(ctx)).filter((t) => typeof t === "object" && t.then));
+}
+__name(registerAll, "registerAll");
+
+// src/data/database.ts
+async function init(ctx) {
+  ctx.model.extend("countdown", {
+    id: "unsigned",
+    uid: "unsigned",
+    channel: "string",
+    platform: "string",
+    text: "string",
+    until: "timestamp",
+    time: "json"
+  }, {
+    autoInc: true
+  });
+}
+__name(init, "init");
+
+// src/index.ts
+var name = "countdown";
+var Config = import_koishi.Schema.object({});
+var inject = {
+  required: ["database"]
+};
+function apply(ctx) {
+  init(ctx);
+  registerAll(ctx);
+  ctx.i18n.define("zh-CN", require_zh_CN());
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/lib/job/checkCountDown.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "koishi";
+export declare function registerCheckDown(ctx: Context): void;

package/lib/reg.d.ts

@@ -0,0 +1,3 @@
+import { Context } from "koishi";
+export type FeatureRegister = (ctx: Context) => Promise<void> | any;
+export declare function registerAll(ctx: Context): Promise<any[]>;

package/lib/types/countdown.d.ts

@@ -0,0 +1,15 @@
+export type CountDownData = {
+    id: number;
+    uid: number;
+    channel: string;
+    platform: string;
+    until: Date;
+    text: string;
+    time: Time;
+};
+export type Time = {
+    s?: number;
+    m?: number;
+    h?: number;
+    d?: number;
+};

package/lib/utils/time.d.ts

@@ -0,0 +1,7 @@
+import { Context, Session } from "koishi";
+import { Time } from "../types/countdown";
+export declare function getTimeStrSess(session: Session, time: Time): any;
+export declare function getTimeStrCtx(ctx: Context, locales: string[], time: Time): any;
+export declare function parseTimeStr(str: string): Time;
+export declare function getTimeAfter(time: Time): Date;
+export declare function getTimeTo(end: Date): Time;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "koishi-plugin-countdown-clock",
+  "description": "Setup an countdown clock and notify the user after a period of time.",
+  "version": "1.0.0",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zxy19/koishi-countdown.git"
+  },
+  "devDependencies": {
+    "@koishijs/plugin-database-sqlite": "*"
+  },
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  },
+  "koishi": {
+    "description": {
+      "en": "Setup an countdown clock and notify the user after a period of time.",
+      "zh": "设置一个倒计时,用于在一段时间后提醒用户"
+    },
+    "service": {
+      "required": [
+        "database"
+      ]
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-countdown
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-countdown?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-countdown)
+
+Setup an countdown clock and notify the user after a period of time.