line_hono 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Luis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# 🔥 LINE Hono [![npm v](https://img.shields.io/npm/v/line-hono)](https://www.npmjs.com/package/line-hono)
+
+**This library enables you to easily build LINE bots on Cloudflare Workers**
+
+This project is influenced by [Hono](https://github.com/honojs/hono).  
+Thank you for [Yusuke Wada](https://github.com/yusukebe) and Hono contributors!
+
+## Features
+
+- **Intuitive API** - Influenced by Hono, offering a familiar and easy-to-use interface.
+- **Flattened Context** - Call `c.text()`, `c.flex()`, etc., directly on the context.
+- **Functional Flex API** - Zero-overhead, pure functions for building Flex messages.
+- **JSX Support** - Use JSX markup to design complex Flex messages.
+- **Lightweight** - Minimal dependencies, optimized for edge environments.
+- **Type-Safe** - Native support for LINE Messaging API types.
+
+## Install
+
+```shell
+npm i line-hono
+```
+
+## Docs
+
+- [`docs/index.md`](./docs/index.md)
+
+## Example Code
+
+```ts
+import { LineHono } from 'line-hono'
+
+const app = new LineHono()
+
+app.message('ping', (c) => c.text('pong'))
+
+app.follow((c) => c.text('Thanks for following!'))
+
+export default app
+```
+
+### Functional Flex Message
+
+```ts
+import { bubble, box, text } from 'line-hono'
+
+app.message('flex', (c) => {
+  return c.flex('Alt text', bubble({
+    body: box('vertical', [
+      text('Hello from line-hono!')
+    ])
+  }))
+})
+```
+
+### JSX Flex Message (Optional)
+
+```tsx
+/** @jsx jsx */
+/** @jsxFrag Fragment */
+import { jsx } from 'line-hono/jsx'
+import { Bubble, Box, Text } from 'line-hono/jsx'
+
+app.message('jsx', (c) => {
+  return c.flex('Alt text', (
+    <Bubble>
+      <Box layout="vertical">
+        <Text>Hello from JSX!</Text>
+      </Box>
+    </Bubble>
+  ))
+})
+```
+
+## Environment Variables
+
+- `LINE_CHANNEL_ACCESS_TOKEN`: Channel Access Token from LINE Developers Console
+- `LINE_CHANNEL_SECRET`: Channel Secret from LINE Developers Console
+
+## References
+
+- [Hono](https://github.com/honojs/hono) - [MIT License](https://github.com/honojs/hono/blob/main/LICENSE)
+- [LINE Messaging API Documentation](https://developers.line.biz/en/docs/messaging-api/)

package/dist/chunk-5V7NFQAQ.js

@@ -0,0 +1,69 @@
+// src/flex.ts
+var omit = (obj, keys) => {
+  const result = { ...obj };
+  for (const key of keys) {
+    if (key in result) delete result[key];
+  }
+  return result;
+};
+var bubble = (options = {}) => ({
+  type: "bubble",
+  ...omit(options, ["children"])
+});
+var carousel = (contents, options = {}) => ({
+  type: "carousel",
+  contents,
+  ...omit(options, ["children"])
+});
+var box = (layout, contents, options = {}) => ({
+  type: "box",
+  layout,
+  contents,
+  ...omit(options, ["children"])
+});
+var text = (text2, options = {}) => ({
+  type: "text",
+  text: text2,
+  ...omit(options, ["children"])
+});
+var button = (action, options = {}) => ({
+  type: "button",
+  action: typeof action === "string" ? { type: "uri", label: action, uri: action } : action,
+  ...omit(options, ["children"])
+});
+var image = (url, options = {}) => ({
+  type: "image",
+  url,
+  ...omit(options, ["children"])
+});
+var icon = (url, options = {}) => ({
+  type: "icon",
+  url,
+  ...omit(options, ["children"])
+});
+var span = (text2, options = {}) => ({
+  type: "span",
+  text: text2,
+  ...omit(options, ["children"])
+});
+var separator = (options = {}) => ({
+  type: "separator",
+  ...omit(options, ["children"])
+});
+var filler = (options = {}) => ({
+  type: "filler",
+  ...omit(options, ["children"])
+});
+
+export {
+  bubble,
+  carousel,
+  box,
+  text,
+  button,
+  image,
+  icon,
+  span,
+  separator,
+  filler
+};

package/dist/index.js

@@ -0,0 +1,404 @@
+import {
+  box,
+  bubble,
+  button,
+  carousel,
+  filler,
+  icon,
+  image,
+  separator,
+  span,
+  text
+} from "./chunk-5V7NFQAQ.js";
+
+// src/context.ts
+import { messagingApi } from "@line/bot-sdk";
+var Context = class {
+  #env;
+  #executionCtx;
+  #line;
+  #event;
+  #var = /* @__PURE__ */ new Map();
+  #client;
+  constructor(env, executionCtx, line, event) {
+    this.#env = env;
+    this.#executionCtx = executionCtx;
+    this.#line = line;
+    this.#event = event;
+  }
+  /**
+   * Environment Variables
+   */
+  get env() {
+    return this.#env;
+  }
+  /**
+   * Execution Context (for cloudflare workers, etc.)
+   */
+  get executionCtx() {
+    return this.#executionCtx;
+  }
+  /**
+   * The raw LINE Webhook Event object.
+   */
+  get event() {
+    return this.#event;
+  }
+  /**
+   * ID of the user who sent the event.
+   */
+  get userId() {
+    return "source" in this.#event && this.#event.source && "userId" in this.#event.source ? this.#event.source.userId : void 0;
+  }
+  /**
+   * ID of the group where the event occurred.
+   */
+  get groupId() {
+    return "source" in this.#event && this.#event.source && "groupId" in this.#event.source ? this.#event.source.groupId : void 0;
+  }
+  /**
+   * ID of the room where the event occurred.
+   */
+  get roomId() {
+    return "source" in this.#event && this.#event.source && "roomId" in this.#event.source ? this.#event.source.roomId : void 0;
+  }
+  /**
+   * Set a variable in the context.
+   */
+  set(key, value) {
+    this.#var.set(key, value);
+  }
+  /**
+   * Get a variable from the context.
+   */
+  get(key) {
+    return this.#var.get(key);
+  }
+  /**
+   * All variables in the context.
+   */
+  get var() {
+    return Object.fromEntries(this.#var);
+  }
+  /**
+   * Official @line/bot-sdk MessagingApiClient instance.
+   */
+  get client() {
+    if (!this.#client) {
+      if (!this.#line.CHANNEL_ACCESS_TOKEN) {
+        throw new Error("CHANNEL_ACCESS_TOKEN is required to initialize the LINE API client.");
+      }
+      this.#client = new messagingApi.MessagingApiClient({
+        channelAccessToken: this.#line.CHANNEL_ACCESS_TOKEN
+      });
+    }
+    return this.#client;
+  }
+  /**
+   * Reply to the current event.
+   * Usage: `c.reply(messages)` or `c.reply.text('Hello')`
+   */
+  /*
+   * Aliases for reply methods
+   */
+  get text() {
+    return this.reply.text;
+  }
+  get image() {
+    return this.reply.image;
+  }
+  get video() {
+    return this.reply.video;
+  }
+  get audio() {
+    return this.reply.audio;
+  }
+  get location() {
+    return this.reply.location;
+  }
+  get sticker() {
+    return this.reply.sticker;
+  }
+  get flex() {
+    return this.reply.flex;
+  }
+  get template() {
+    return this.reply.template;
+  }
+  get reply() {
+    const fn = async (messages) => {
+      if ("replyToken" in this.#event) {
+        const replyToken = this.#event.replyToken;
+        if (typeof replyToken === "string") {
+          return this.client.replyMessage({
+            replyToken,
+            messages: Array.isArray(messages) ? messages : [messages]
+          });
+        }
+      }
+      throw new Error("This event does not support reply");
+    };
+    fn.text = (text2) => fn({ type: "text", text: text2 });
+    fn.image = (url, previewUrl) => fn({ type: "image", originalContentUrl: url, previewImageUrl: previewUrl || url });
+    fn.video = (url, previewUrl) => fn({ type: "video", originalContentUrl: url, previewImageUrl: previewUrl });
+    fn.audio = (url, duration) => fn({ type: "audio", originalContentUrl: url, duration });
+    fn.location = (title, address, lat, lon) => fn({ type: "location", title, address, latitude: lat, longitude: lon });
+    fn.sticker = (packageId, stickerId) => fn({ type: "sticker", packageId, stickerId });
+    fn.flex = (altText, contents) => {
+      return fn({ type: "flex", altText, contents });
+    };
+    fn.template = (altText, template) => fn({ type: "template", altText, template });
+    return fn;
+  }
+  /**
+   * Send a push message to the current source (user, group, or room).
+   * Usage: `c.push(messages)` or `c.push.text('Hello')`
+   */
+  get push() {
+    const fn = async (messages) => {
+      const to = this.userId || this.groupId || this.roomId;
+      if (!to) throw new Error("No destination found for push");
+      return this.client.pushMessage({
+        to,
+        messages: Array.isArray(messages) ? messages : [messages]
+      });
+    };
+    fn.text = (text2) => fn({ type: "text", text: text2 });
+    fn.image = (url, previewUrl) => fn({ type: "image", originalContentUrl: url, previewImageUrl: previewUrl || url });
+    fn.video = (url, previewUrl) => fn({ type: "video", originalContentUrl: url, previewImageUrl: previewUrl });
+    fn.audio = (url, duration) => fn({ type: "audio", originalContentUrl: url, duration });
+    fn.location = (title, address, lat, lon) => fn({ type: "location", title, address, latitude: lat, longitude: lon });
+    fn.sticker = (packageId, stickerId) => fn({ type: "sticker", packageId, stickerId });
+    fn.flex = (altText, contents) => {
+      return fn({ type: "flex", altText, contents });
+    };
+    fn.template = (altText, template) => fn({ type: "template", altText, template });
+    return fn;
+  }
+};
+
+// src/utils.ts
+var newError = (locate, text2) => new Error(`line-hono(${locate}): ${text2}`);
+
+// src/verify.ts
+var verify = async (body, signature, secret) => {
+  if (!body || !signature || !secret) return false;
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw newError("verify", "crypto");
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(secret);
+  const key = await subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const signatureBuffer = await subtle.sign("HMAC", key, encoder.encode(body));
+  const generatedSignature = btoa(String.fromCharCode(...new Uint8Array(signatureBuffer)));
+  return generatedSignature === signature;
+};
+
+// src/line-hono.ts
+var LineHono = class {
+  #verify;
+  #line;
+  #handlers = /* @__PURE__ */ new Map();
+  #commands = /* @__PURE__ */ new Map();
+  #components = /* @__PURE__ */ new Map();
+  #modals = /* @__PURE__ */ new Map();
+  #crons = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#verify = options?.verify ?? verify;
+    this.#line = (env) => {
+      const lineEnv = options?.lineEnv ? options.lineEnv(env) : {};
+      const bindings = env || {};
+      return {
+        CHANNEL_SECRET: lineEnv.CHANNEL_SECRET || bindings["LINE_CHANNEL_SECRET"],
+        CHANNEL_ACCESS_TOKEN: lineEnv.CHANNEL_ACCESS_TOKEN || bindings["LINE_CHANNEL_ACCESS_TOKEN"]
+      };
+    };
+  }
+  /**
+   * Register a handler for a specific LINE event type.
+   * @param type Event type (e.g., 'message', 'follow', 'postback')
+   * @param handler Handler function
+   */
+  on(type, handler) {
+    if (!this.#handlers.has(type)) {
+      this.#handlers.set(type, []);
+    }
+    this.#handlers.get(type)?.push(handler);
+    return this;
+  }
+  /**
+   * Register a handler for 'message' events.
+   */
+  message(handler) {
+    return this.on("message", handler);
+  }
+  /**
+   * Register a handler for 'follow' events.
+   */
+  follow(handler) {
+    return this.on("follow", handler);
+  }
+  /**
+   * Register a handler for 'unfollow' events.
+   */
+  unfollow(handler) {
+    return this.on("unfollow", handler);
+  }
+  /**
+   * Register a handler for 'postback' events.
+   */
+  postback(handler) {
+    return this.on("postback", handler);
+  }
+  /**
+   * Register a handler for 'join' events.
+   */
+  join(handler) {
+    return this.on("join", handler);
+  }
+  /**
+   * Register a handler for 'leave' events.
+   */
+  leave(handler) {
+    return this.on("leave", handler);
+  }
+  /**
+   * Register a handler for 'beacon' events.
+   */
+  beacon(handler) {
+    return this.on("beacon", handler);
+  }
+  /**
+   * Register high-level handlers from a factory.
+   */
+  loader(handlers) {
+    for (const h of handlers) {
+      if (h.type === "command") this.command(h.command.name, h.handler);
+      else if (h.type === "component") this.component(h.component.id, h.handler);
+      else if (h.type === "modal") this.modal(h.modal.id, h.handler);
+      else if (h.type === "cron") this.cron(h.cron, h.handler);
+      else throw new Error(`Unknown handler type: ${JSON.stringify(h)}`);
+    }
+  }
+  command(name, handler) {
+    this.#commands.set(name, handler);
+    return this;
+  }
+  component(id, handler) {
+    this.#components.set(id, handler);
+    return this;
+  }
+  modal(id, handler) {
+    this.#modals.set(id, handler);
+    return this;
+  }
+  cron(expression, handler) {
+    this.#crons.set(expression, handler);
+    return this;
+  }
+  fetch = async (request, env, executionCtx) => {
+    if (request.method === "GET") {
+      return new Response("Operational\u{1F525}");
+    }
+    if (request.method !== "POST") {
+      return new Response("Not Found", { status: 404 });
+    }
+    const line = this.#line(env);
+    if (!line.CHANNEL_SECRET) throw newError("LineHono", "LINE_CHANNEL_SECRET");
+    const body = await request.text();
+    const signature = request.headers.get("x-line-signature");
+    if (!await this.#verify(body, signature, line.CHANNEL_SECRET)) {
+      return new Response("Unauthorized", { status: 401 });
+    }
+    const data = JSON.parse(body);
+    const promises = data.events.flatMap((event) => {
+      const handlers = this.#handlers.get(event.type) || [];
+      return handlers.map(async (handler) => {
+        const c = new Context(env, executionCtx, line, event);
+        return handler(c);
+      });
+    });
+    if (executionCtx?.waitUntil) {
+      executionCtx.waitUntil(Promise.all(promises));
+    } else {
+      await Promise.all(promises);
+    }
+    return new Response("OK");
+  };
+};
+
+// src/builders.ts
+var Command = class {
+  name;
+  description;
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+};
+var Button = class {
+  id;
+  label;
+  constructor(id, label) {
+    this.id = id;
+    this.label = label;
+  }
+};
+var Modal = class {
+  id;
+  title;
+  constructor(id, title) {
+    this.id = id;
+    this.title = title;
+  }
+};
+
+// src/helpers/create-factory.ts
+var createFactory = () => {
+  return {
+    line: () => new LineHono(),
+    command: (name, description, handler) => ({
+      type: "command",
+      command: new Command(name, description),
+      handler
+    }),
+    component: (id, label, handler) => ({
+      type: "component",
+      component: new Button(id, label),
+      handler
+    }),
+    autocomplete: (command, autocomplete, handler) => ({
+      type: "autocomplete",
+      command,
+      autocomplete,
+      handler
+    }),
+    modal: (id, title, handler) => ({
+      type: "modal",
+      modal: new Modal(id, title),
+      handler
+    }),
+    cron: (cron, handler) => ({ type: "cron", cron, handler }),
+    getCommands: (handlers) => {
+      return handlers.filter((h) => h.type === "command").map((h) => h.command);
+    }
+  };
+};
+export {
+  Button,
+  Command,
+  Context,
+  LineHono,
+  Modal,
+  box,
+  bubble,
+  button,
+  carousel,
+  createFactory,
+  filler,
+  icon,
+  image,
+  newError,
+  separator,
+  span,
+  text
+};

package/dist/jsx.js

@@ -0,0 +1,86 @@
+import {
+  box,
+  bubble,
+  button,
+  carousel,
+  filler,
+  icon,
+  image,
+  separator,
+  span,
+  text
+} from "./chunk-5V7NFQAQ.js";
+
+// src/jsx.ts
+var jsx = (tag, props, ...children) => {
+  if (typeof tag === "function") {
+    return tag({ ...props, children: children.length === 1 ? children[0] : children });
+  }
+  const flattenedChildren = children.flat(Infinity).filter(Boolean);
+  const p = props || {};
+  switch (tag.toLowerCase()) {
+    case "bubble":
+      return bubble({ ...p, body: flattenedChildren.find((c) => c.type === "box") });
+    case "carousel":
+      return carousel(flattenedChildren);
+    case "box":
+      return box(p["layout"] || "vertical", flattenedChildren, p);
+    case "text":
+      return text(p["text"] || (typeof children[0] === "string" ? children[0] : ""), p);
+    case "button":
+      return button(p["action"], p);
+    case "image":
+      return image(p["url"], p);
+    case "icon":
+      return icon(p["url"], p);
+    case "span":
+      return span(p["text"] || (typeof children[0] === "string" ? children[0] : ""), p);
+    case "separator":
+      return separator(p);
+    case "filler":
+      return filler(p);
+    default:
+      return { type: tag, ...p, contents: flattenedChildren };
+  }
+};
+var h = jsx;
+var Bubble = (props) => {
+  const children = Array.isArray(props.children) ? props.children : [props.children];
+  const body = children.find((c) => c?.type === "box");
+  return bubble({ ...props, body });
+};
+var Carousel = (props) => {
+  const children = Array.isArray(props.children) ? props.children : [props.children];
+  return carousel(children, props);
+};
+var Box = (props) => {
+  const children = Array.isArray(props.children) ? props.children : [props.children];
+  return box(props.layout || "vertical", children, props);
+};
+var Text = (props) => {
+  const textContent = props.text || (typeof props.children === "string" ? props.children : void 0);
+  return text(textContent, props);
+};
+var Button = (props) => button(props.action, props);
+var Image = (props) => image(props.url, props);
+var Icon = (props) => icon(props.url, props);
+var Span = (props) => {
+  const textContent = props.text || (typeof props.children === "string" ? props.children : void 0);
+  return span(textContent, props);
+};
+var Separator = (props) => separator(props);
+var Filler = (props) => filler(props);
+export {
+  Box,
+  Bubble,
+  Button,
+  Carousel,
+  Filler,
+  Icon,
+  Image,
+  Separator,
+  Span,
+  Text,
+  h,
+  jsx
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "line_hono",
+  "version": "0.1.1",
+  "description": "This library enables you to easily build LINE bots on Cloudflare Workers",
+  "license": "MIT",
+  "keywords": [
+    "line-hono",
+    "line-bot",
+    "cloudflare-workers"
+  ],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./jsx": {
+      "types": "./dist/jsx.d.ts",
+      "import": "./dist/jsx.js"
+    }
+  },
+  "engines": {
+    "node": ">=18.4.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@biomejs/biome": "^2.4.4",
+    "@tsconfig/strictest": "^2.0.8",
+    "@vitest/coverage-v8": "^4.0.18",
+    "hono": "^4.12.3",
+    "mitata": "^1.0.34",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@line/bot-sdk": "^10.6.0"
+  },
+  "scripts": {
+    "fix": "biome check --write .",
+    "fix:unsafe": "biome check --write --unsafe .",
+    "test": "biome check . && tsc && vitest run --coverage",
+    "build": "tsup src/index.ts src/jsx.ts --format esm --dts --clean && attw -P . --ignore-rules cjs-resolves-to-esm"
+  }
+}