@sns-parse/core 0.4.0-alpha.9 → 0.6.0-alpha.1

package/lib/workflow/default.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultPipeline = createDefaultPipeline;
+const hooks_1 = require("./hooks");
+const fetcher = __importStar(require("../engine/fetcher"));
+const compose = __importStar(require("../engine/compose"));
+const forward = __importStar(require("../engine/forward"));
+async function sendDispatch(rt, input) {
+    const { items, session, sender, quoteId } = input;
+    const config = rt.config || {};
+    const forwardAllowed = config.enableForward && (session.platform === 'onebot' || session.platform === 'satori');
+    if (forwardAllowed) {
+        await forward.sendForward(rt, sender, session, items);
+        return;
+    }
+    if (config.sendStrategy === 'split') {
+        for (const item of items)
+            await compose.sendSplit(rt, sender, session, item, { quoteId });
+        return;
+    }
+    for (const item of items) {
+        await compose.sendSingle(rt, sender, session, item, { quoteId });
+    }
+}
+/** 构建带全部基线实现的管道；随后调用各扩展 setup(hooks) 注入/覆盖 */
+function createDefaultPipeline(rt) {
+    const p = new hooks_1.Pipeline(rt);
+    p.replace('parse', (input, r) => fetcher.fetchApi(r, input.url, input.type, input.fieldMapping, input.platformConf));
+    p.replace('translate', async () => null);
+    p.replace('media.image', async (input) => ({ kind: 'raw', url: input.url }));
+    p.replace('media.video', async (input) => ({ kind: 'raw', url: input.videoUrl }));
+    p.replace('media.merged', async (input) => ({ kind: 'raw', buffer: input.buffer, url: input.refUrl }));
+    p.replace('merge', async () => null);
+    p.replace('transcode', async () => null);
+    p.replace('compose', (input, r) => compose.buildUnits(r, input.item));
+    p.replace('send', (input, r) => sendDispatch(r, input));
+    return p;
+}

package/lib/workflow/hooks.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 工作流阶段钩子管道（core 内建完整工作流，扩展经钩子注入/修改）。
+ *
+ * 每阶段结构：{ before[], impl, after[] }
+ * - before：前置，可改输入（返回新输入；返回 undefined 表示不变）
+ * - after：后置，可改输出（返回新输出；返回 undefined 表示不变）
+ * - replace：整体替换该阶段实现（后注册者胜）
+ *
+ * 基线实现见 workflow/default.ts（无扩展时全链路可跑：
+ * 不合并逐张发 / GIF 退化发视频 / 不翻译 / 媒体直通）。
+ */
+import type { ParsedData } from '../types';
+import type { ImageOutcome, VideoOutcome, TranslateResult, GifOptions, MediaKind, VideoMeta } from '../extensions';
+import type { ProcessedItem, MessageUnit } from '../engine/compose';
+import type { OutboundSender, SessionLike } from '../sender';
+export type StageName = 'parse' | 'translate' | 'media.image' | 'media.video' | 'media.merged' | 'merge' | 'transcode' | 'compose' | 'send';
+export interface ParseInput {
+    url: string;
+    type: string;
+    fieldMapping?: Record<string, string>;
+    platformConf?: any;
+}
+export interface TranslateInput {
+    text: string;
+    target: string;
+    sourceLang?: string;
+}
+export interface MediaImageInput {
+    platform: string;
+    url: string;
+    kind: MediaKind;
+}
+export interface MediaVideoInput {
+    platform: string;
+    videoUrl: string;
+    coverUrl: string;
+    meta: VideoMeta;
+}
+export interface MediaMergedInput {
+    platform: string;
+    buffer: Buffer;
+    refUrl: string;
+}
+export interface MergeInput {
+    urls: string[];
+}
+export type MergeResult = {
+    buffer: Buffer;
+    layout?: any;
+} | null;
+export interface TranscodeInput {
+    url: string;
+    durationSec: number;
+    opts: GifOptions;
+}
+export interface ComposeInput {
+    item: ProcessedItem;
+}
+export interface SendInput {
+    items: ProcessedItem[];
+    session: SessionLike;
+    sender: OutboundSender;
+    quoteId?: string;
+}
+export interface StageIO {
+    parse: {
+        input: ParseInput;
+        output: ParsedData;
+    };
+    translate: {
+        input: TranslateInput;
+        output: TranslateResult | null;
+    };
+    'media.image': {
+        input: MediaImageInput;
+        output: ImageOutcome;
+    };
+    'media.video': {
+        input: MediaVideoInput;
+        output: VideoOutcome;
+    };
+    'media.merged': {
+        input: MediaMergedInput;
+        output: ImageOutcome | null;
+    };
+    merge: {
+        input: MergeInput;
+        output: MergeResult;
+    };
+    transcode: {
+        input: TranscodeInput;
+        output: Buffer | null;
+    };
+    compose: {
+        input: ComposeInput;
+        output: MessageUnit[];
+    };
+    send: {
+        input: SendInput;
+        output: void;
+    };
+}
+export type StageImpl<S extends StageName = StageName> = (input: StageIO[S]['input'], rt: any) => StageIO[S]['output'] | Promise<StageIO[S]['output']>;
+export type BeforeHandler<S extends StageName = StageName> = (input: StageIO[S]['input'], rt: any) => StageIO[S]['input'] | void | Promise<StageIO[S]['input'] | void>;
+export type AfterHandler<S extends StageName = StageName> = (output: StageIO[S]['output'], input: StageIO[S]['input'], rt: any) => StageIO[S]['output'] | void | Promise<StageIO[S]['output'] | void>;
+/** 扩展注入面：before/after 可插入，replace 可整体替换（后注册者胜） */
+export interface WorkflowHooks {
+    before<S extends StageName>(stage: S, h: BeforeHandler<S>): void;
+    after<S extends StageName>(stage: S, h: AfterHandler<S>): void;
+    replace<S extends StageName>(stage: S, h: StageImpl<S>): void;
+}
+export declare class Pipeline implements WorkflowHooks {
+    rt: any;
+    private impls;
+    private befores;
+    private afters;
+    constructor(rt: any);
+    before<S extends StageName>(stage: S, h: BeforeHandler<S>): void;
+    after<S extends StageName>(stage: S, h: AfterHandler<S>): void;
+    replace<S extends StageName>(stage: S, h: StageImpl<S>): void;
+    run<S extends StageName>(stage: S, input: StageIO[S]['input']): Promise<StageIO[S]['output']>;
+}
+/** 取（或懒挂）runtime 的管道；裸 rt 对象也能工作（自动挂默认管道）。 */
+export declare function ensurePipeline(rt: any): Pipeline;
+export declare function runStage<S extends StageName>(rt: any, stage: S, input: StageIO[S]['input']): Promise<StageIO[S]['output']>;

package/lib/workflow/hooks.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipeline = void 0;
+exports.ensurePipeline = ensurePipeline;
+exports.runStage = runStage;
+class Pipeline {
+    constructor(rt) {
+        this.rt = rt;
+        this.impls = new Map();
+        this.befores = new Map();
+        this.afters = new Map();
+    }
+    before(stage, h) {
+        const list = this.befores.get(stage) || [];
+        list.push(h);
+        this.befores.set(stage, list);
+    }
+    after(stage, h) {
+        const list = this.afters.get(stage) || [];
+        list.push(h);
+        this.afters.set(stage, list);
+    }
+    replace(stage, h) {
+        this.impls.set(stage, h);
+    }
+    async run(stage, input) {
+        let cur = input;
+        for (const h of this.befores.get(stage) || []) {
+            const r = await h(cur, this.rt);
+            if (r !== undefined)
+                cur = r;
+        }
+        const impl = this.impls.get(stage);
+        if (!impl)
+            throw new Error(`workflow: 阶段缺少实现: ${stage}`);
+        let out = await impl(cur, this.rt);
+        for (const h of this.afters.get(stage) || []) {
+            const r = await h(out, cur, this.rt);
+            if (r !== undefined)
+                out = r;
+        }
+        return out;
+    }
+}
+exports.Pipeline = Pipeline;
+/** 取（或懒挂）runtime 的管道；裸 rt 对象也能工作（自动挂默认管道）。 */
+function ensurePipeline(rt) {
+    if (rt && rt.pipeline instanceof Pipeline)
+        return rt.pipeline;
+    const { createDefaultPipeline } = require('./default');
+    const p = createDefaultPipeline(rt);
+    if (rt)
+        rt.pipeline = p;
+    return p;
+}
+function runStage(rt, stage, input) {
+    return ensurePipeline(rt).run(stage, input);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sns-parse/core",
-  "version": "0.4.0-alpha.9+upstream.1.6.7",
+  "version": "0.6.0-alpha.1+upstream.1.6.7",
   "description": "sns-parse 核心：契约、宿主抽象、配置 DSL 与解析引擎（fetcher/parser/翻译/X 原生解析/合并/GIF/TLS 指纹客户端）",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",