@undefineds.co/xpod 0.4.14 → 0.4.16

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * Execution Module
- *
- * Provides execution strategies for different modes (LDP, SPARQL)
- */
-export type { ExecutionStrategy, ExecutionStrategyFactory, ExecutionResult, ExecutionContext, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './types';
-export { LdpStrategy } from './ldp-strategy';
-export type { LdpStrategyDependencies } from './ldp-strategy';
-export { SparqlStrategy } from './sparql-strategy';
-export type { SparqlStrategyDependencies } from './sparql-strategy';
-export { ExecutionStrategyFactoryImpl } from './strategy-factory';
-export type { StrategyFactoryDependencies } from './strategy-factory';
-export { LdpExecutor } from './ldp-executor';
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/ldp-executor.d.ts

@@ -1,76 +0,0 @@
-/**
- * LDP Executor Implementation
- *
- * 负责 LDP 模式下的写操作 (N3 Patch)，剥离自 PodDialect
- */
-import type { PodTable } from '../schema';
-import type { ComunicaSPARQLExecutor } from '../sparql-executor';
-import type { UriResolver } from '../uri';
-export declare class LdpExecutor {
-    private sparqlExecutor;
-    private fetchFn;
-    private tripleBuilder;
-    private uriResolver;
-    constructor(sparqlExecutor: ComunicaSPARQLExecutor, fetchFn: typeof fetch, uriResolver: UriResolver);
-    /**
-     * 设置表注册表（用于 URI 引用自动补全）
-     * @param classRegistry rdfClass -> tables[] 的映射
-     * @param nameRegistry tableName -> table 的映射
-     */
-    setTableRegistry(classRegistry: Map<string, PodTable[]>, nameRegistry: Map<string, PodTable>): void;
-    /**
-     * 设置基础 URI
-     */
-    setBaseUri(uri: string): void;
-    /**
-     * 执行 INSERT 操作
-     */
-    executeInsert(rows: any[], table: PodTable, resourceUrl: string, options?: {
-        ensureContainerExists?: (containerUrl: string) => Promise<void>;
-        repairContainerOnWriteFailure?: (containerUrl: string) => Promise<void>;
-        skipResourceExistenceCheck?: boolean;
-        tableRegistry?: Map<string, PodTable[]>;
-        tableNameRegistry?: Map<string, PodTable>;
-    }): Promise<any[]>;
-    private repairContainerAndRetryPutIfNeeded;
-    private isMissingParentContainerResponse;
-    /**
-     * 执行 UPDATE 操作
-     */
-    executeUpdate(table: PodTable, data: Record<string, any>, subjects: string[], resourceUrl: string): Promise<any[]>;
-    /**
-     * 执行 DELETE 操作
-     */
-    executeDelete(subjects: string[], table: PodTable, resourceUrl: string): Promise<any[]>;
-    /**
-     * Execute a function with exponential backoff retry on server errors
-     */
-    private retryWithBackoff;
-    /**
-     * Build error from failed response
-     */
-    private buildPatchError;
-    private buildUpdatePatchPayload;
-    private sameTripleSet;
-    /**
-     * 执行更新操作
-     *
-     * 优先尝试 SPARQL UPDATE (application/sparql-update)，
-     * xpod 内部使用 SPARQL，标准 CSS 也支持。
-     * 如果失败，回退到 N3 Patch。
-     */
-    private executeN3Patch;
-    /**
-     * 构建 SPARQL UPDATE 查询
-     */
-    private buildSparqlUpdate;
-    /**
-     * 内部 N3 Patch 实现（作为 SPARQL UPDATE 的回退）
-     */
-    private executeN3PatchInternal;
-    private formatTerm;
-    private fetchRecursiveTriplesToDelete;
-    private fetchExistingObjects;
-    private fetchInverseSubjects;
-}
-//# sourceMappingURL=ldp-executor.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/ldp-strategy.d.ts

@@ -1,53 +0,0 @@
-/**
- * LDP Execution Strategy
- *
- * Implements ExecutionStrategy for LDP mode.
- * - SELECT: Uses Comunica to query RDF resources
- * - INSERT/UPDATE/DELETE: Uses N3 Patch or PUT
- */
-import type { PodTable } from '../schema';
-import type { ComunicaSPARQLExecutor } from '../sparql-executor';
-import type { ASTToSPARQLConverter } from '../ast-to-sparql';
-import type { ResourceResolver } from '../resource-resolver';
-import type { QueryCondition } from '../query-conditions';
-import type { SelectQueryPlan } from '../select-plan';
-import type { ExecutionStrategy, ExecutionResult, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './types';
-import { LdpExecutor } from './ldp-executor';
-export interface LdpStrategyDependencies {
-    sparqlExecutor: ComunicaSPARQLExecutor;
-    sparqlConverter: ASTToSPARQLConverter;
-    fetchFn: typeof fetch;
-    ldpExecutor: LdpExecutor;
-    getResolver: (table: PodTable) => ResourceResolver;
-    listContainerResources: (containerUrl: string) => Promise<string[]>;
-    findSubjectsForCondition: (condition: QueryCondition, table: PodTable, resourceUrl: string) => Promise<string[]>;
-}
-export declare class LdpStrategy implements ExecutionStrategy {
-    readonly mode: "ldp";
-    private sparqlExecutor;
-    private sparqlConverter;
-    private fetchFn;
-    private ldpExecutor;
-    private getResolver;
-    private listContainerResources;
-    private findSubjectsForCondition;
-    constructor(deps: LdpStrategyDependencies);
-    /**
-     * Execute SELECT query in LDP mode
-     * Uses ResourceResolver to determine which sources to query
-     */
-    executeSelect(plan: SelectQueryPlan, containerUrl: string, _resourceUrl: string): Promise<any[]>;
-    /**
-     * Execute INSERT operation in LDP mode
-     */
-    executeInsert(plan: InsertQueryPlan, _containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
-    /**
-     * Execute UPDATE operation in LDP mode
-     */
-    executeUpdate(plan: UpdateQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
-    /**
-     * Execute DELETE operation in LDP mode
-     */
-    executeDelete(plan: DeleteQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
-}
-//# sourceMappingURL=ldp-strategy.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/pod-executor-types.d.ts

@@ -1,9 +0,0 @@
-export type TableResourceDescriptor = {
-    mode: 'ldp';
-    containerUrl: string;
-    resourceUrl: string;
-} | {
-    mode: 'sparql';
-    endpoint: string;
-};
-//# sourceMappingURL=pod-executor-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/pod-executor.d.ts

@@ -1,73 +0,0 @@
-import type { PodTable } from '../schema';
-import type { PodOperation } from '../pod-dialect';
-import type { QueryCondition } from '../query-conditions';
-import type { SelectQueryPlan } from '../select-plan';
-import type { InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from '../pod-session';
-import type { ASTToSPARQLConverter } from '../ast-to-sparql';
-import type { ComunicaSPARQLExecutor } from '../sparql-executor';
-import type { ExecutionStrategy } from './types';
-import type { TableResourceDescriptor } from './pod-executor-types';
-export interface PodExecutorDeps {
-    ensureConnected: () => Promise<void>;
-    ensureTableResourcePath: (table: PodTable) => Promise<void>;
-    resolveTableResource: (table: PodTable) => TableResourceDescriptor;
-    resolveTableUrls: (table: PodTable) => {
-        containerUrl: string;
-        resourceUrl: string;
-    };
-    normalizeResourceUrl: (resourceUrl: string) => string;
-    normalizeContainerKey: (containerUrl: string) => string;
-    normalizeResourceKey: (resourceUrl: string) => string;
-    ensureContainerExists: (containerUrl: string) => Promise<void>;
-    ensureResourceExists: (resourceUrl: string, options?: {
-        createIfMissing?: boolean;
-    }) => Promise<void>;
-    shouldSkipResourcePreparation?: () => boolean;
-    shouldUseWriteTimeResourcePreparation?: () => boolean;
-    shouldContinueAfterResourcePreparationError?: () => boolean;
-    getTableRegistries?: () => {
-        tableRegistry: Map<string, PodTable[]>;
-        tableNameRegistry: Map<string, PodTable>;
-    };
-    ensureIdentifierCondition: (condition: QueryCondition | undefined, table: PodTable, resourceUrl: string) => Promise<QueryCondition | undefined>;
-    resourceExists: (resourceUrl: string) => Promise<boolean>;
-    getStrategy: (table: PodTable) => ExecutionStrategy;
-    getLdpStrategy: () => ExecutionStrategy;
-    preparedContainers: Set<string>;
-    preparedResources: Set<string>;
-    sparqlConverter: ASTToSPARQLConverter;
-    sparqlExecutor: ComunicaSPARQLExecutor;
-    isSelectPlan: (plan: unknown) => plan is SelectQueryPlan;
-    isInsertPlan: (plan: unknown) => plan is InsertQueryPlan;
-    isUpdatePlan: (plan: unknown) => plan is UpdateQueryPlan;
-    isDeletePlan: (plan: unknown) => plan is DeleteQueryPlan;
-}
-export declare class PodExecutor {
-    private deps;
-    constructor(deps: PodExecutorDeps);
-    query(operation: PodOperation): Promise<unknown[]>;
-    private shouldSkipResourcePreparation;
-    private shouldUseWriteTimeResourcePreparation;
-    private shouldContinueAfterResourcePreparationError;
-    private prepareResource;
-    /**
-     * Execute SELECT operation via ExecutionStrategy
-     */
-    private executeSelect;
-    private getSelectStrategy;
-    private isExactIriSelect;
-    private getExactSelectResourceUrl;
-    /**
-     * Execute INSERT operation via ExecutionStrategy
-     */
-    private executeInsert;
-    /**
-     * Execute UPDATE operation via ExecutionStrategy
-     */
-    private executeUpdate;
-    /**
-     * Execute DELETE operation via ExecutionStrategy
-     */
-    private executeDelete;
-}
-//# sourceMappingURL=pod-executor.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/sparql-strategy.d.ts

@@ -1,31 +0,0 @@
-import type { ASTToSPARQLConverter } from '../ast-to-sparql';
-import type { SelectQueryPlan } from '../select-plan';
-import type { ComunicaSPARQLExecutor } from '../sparql-executor';
-import type { SPARQLQueryEngineFactory } from '../sparql-engine';
-import type { UriResolver } from '../uri';
-import type { ExecutionStrategy } from './types';
-export interface SparqlStrategyDependencies {
-    sparqlExecutor: ComunicaSPARQLExecutor;
-    sparqlConverter: ASTToSPARQLConverter;
-    sessionFetch: typeof fetch;
-    podUrl: string;
-    uriResolver: UriResolver;
-    createQueryEngine?: SPARQLQueryEngineFactory;
-}
-export declare class SparqlStrategy implements ExecutionStrategy {
-    readonly mode: "sparql";
-    private sparqlExecutor;
-    private sparqlConverter;
-    private podUrl;
-    private uriResolver;
-    private createQueryEngine?;
-    constructor(deps: SparqlStrategyDependencies);
-    setPodUrl(podUrl: string): void;
-    private resolvePodResourceIri;
-    private resolveTargetGraph;
-    executeSelect(plan: SelectQueryPlan, _containerUrl: string, resourceUrl: string): Promise<any[]>;
-    executeInsert(): Promise<any[]>;
-    executeUpdate(): Promise<any[]>;
-    executeDelete(): Promise<any[]>;
-}
-//# sourceMappingURL=sparql-strategy.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/strategy-factory.d.ts

@@ -1,42 +0,0 @@
-/**
- * ExecutionStrategy Factory
- *
- * Creates the appropriate execution strategy based on table configuration.
- * - Tables with sparqlEndpoint -> SparqlStrategy
- * - Tables without sparqlEndpoint -> LdpStrategy
- */
-import type { ASTToSPARQLConverter } from '../ast-to-sparql';
-import type { QueryCondition } from '../query-conditions';
-import type { ResourceResolver } from '../resource-resolver';
-import type { PodTable } from '../schema';
-import type { ComunicaSPARQLExecutor } from '../sparql-executor';
-import type { SPARQLQueryEngineFactory } from '../sparql-engine';
-import type { UriResolver } from '../uri';
-import { LdpStrategy } from './ldp-strategy';
-import type { LdpExecutor } from './ldp-executor';
-import type { ExecutionStrategy, ExecutionStrategyFactory } from './types';
-export interface StrategyFactoryDependencies {
-    sparqlExecutor: ComunicaSPARQLExecutor;
-    sparqlConverter: ASTToSPARQLConverter;
-    sessionFetch: typeof fetch;
-    podUrl: string;
-    createQueryEngine?: SPARQLQueryEngineFactory;
-    ldpExecutor: LdpExecutor;
-    uriResolver: UriResolver;
-    getResolver: (table: PodTable) => ResourceResolver;
-    listContainerResources: (containerUrl: string) => Promise<string[]>;
-    findSubjectsForCondition: (condition: QueryCondition, table: PodTable, resourceUrl: string) => Promise<string[]>;
-}
-export declare class ExecutionStrategyFactoryImpl implements ExecutionStrategyFactory {
-    private deps;
-    private ldpStrategy;
-    private sparqlStrategy;
-    constructor(deps: StrategyFactoryDependencies);
-    setPodUrl(podUrl: string): void;
-    getStrategy(table: PodTable): ExecutionStrategy;
-    getLdpStrategy(): LdpStrategy;
-    private getLdpStrategyInternal;
-    private getSparqlStrategy;
-    static getMode(table: PodTable): 'ldp' | 'sparql';
-}
-//# sourceMappingURL=strategy-factory.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/types.d.ts

@@ -1,85 +0,0 @@
-/**
- * ExecutionStrategy Types
- *
- * Defines the interface for different execution modes (LDP, SPARQL)
- */
-import type { PodTable } from '../schema';
-import type { QueryCondition } from '../query-conditions';
-import type { SelectQueryPlan } from '../select-plan';
-export interface InsertQueryPlan {
-    table: PodTable;
-    rows: any[];
-    ensureContainerExists?: (containerUrl: string) => Promise<void>;
-    repairContainerOnWriteFailure?: (containerUrl: string) => Promise<void>;
-    skipResourceExistenceCheck?: boolean;
-    tableRegistry?: Map<string, PodTable[]>;
-    tableNameRegistry?: Map<string, PodTable>;
-}
-export interface UpdateQueryPlan {
-    table: PodTable;
-    data: Record<string, any>;
-    where: QueryCondition;
-}
-export interface DeleteQueryPlan {
-    table: PodTable;
-    where?: QueryCondition;
-}
-/**
- * Result of an execution operation
- */
-export interface ExecutionResult {
-    success: boolean;
-    source: string;
-    status: number;
-    via?: string;
-    error?: string;
-    retried?: boolean;
-}
-/**
- * Context passed to execution strategies
- */
-export interface ExecutionContext {
-    /** Pod base URL */
-    podUrl: string;
-    /** Authenticated fetch function */
-    fetch: typeof fetch;
-    /** WebID of the current user */
-    webId: string;
-}
-/**
- * ExecutionStrategy interface
- *
- * Abstracts the difference between LDP and SPARQL execution modes.
- * SELECT is required; write operations are optional since SPARQL mode
- * only supports SELECT (writes are routed to LDP for Solid Notifications compatibility).
- */
-export interface ExecutionStrategy {
-    /** Mode identifier */
-    readonly mode: 'ldp' | 'sparql';
-    /**
-     * Execute a SELECT query
-     */
-    executeSelect(plan: SelectQueryPlan, containerUrl: string, resourceUrl: string): Promise<any[]>;
-    /**
-     * Execute an INSERT operation (optional - SPARQL mode does not support writes)
-     */
-    executeInsert?(plan: InsertQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
-    /**
-     * Execute an UPDATE operation (optional - SPARQL mode does not support writes)
-     */
-    executeUpdate?(plan: UpdateQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
-    /**
-     * Execute a DELETE operation (optional - SPARQL mode does not support writes)
-     */
-    executeDelete?(plan: DeleteQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
-}
-/**
- * Factory interface for creating execution strategies
- */
-export interface ExecutionStrategyFactory {
-    /**
-     * Get the appropriate execution strategy for a table
-     */
-    getStrategy(table: PodTable): ExecutionStrategy;
-}
-//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/expressions.d.ts

@@ -1,40 +0,0 @@
-import { PodColumnBase } from './schema';
-type AnyColumn = PodColumnBase<any, any, any, any>;
-type ExpressionValue = unknown;
-/**
- * SPARQL 表达式基类
- * 不再实现 drizzle-orm 的 SQLWrapper 接口，避免假 SQL 对象导致的问题
- */
-export declare abstract class SPARQLExpression {
-    readonly [Symbol.toStringTag] = "SPARQLExpression";
-}
-export declare class BinaryExpression extends SPARQLExpression {
-    left: AnyColumn | SPARQLExpression | string;
-    operator: string;
-    right: ExpressionValue;
-    readonly type = "binary_expr";
-    constructor(left: AnyColumn | SPARQLExpression | string, operator: string, right: ExpressionValue);
-}
-export declare class LogicalExpression extends SPARQLExpression {
-    operator: 'AND' | 'OR';
-    expressions: (SPARQLExpression | ExpressionValue)[];
-    readonly type = "logical_expr";
-    constructor(operator: 'AND' | 'OR', expressions: (SPARQLExpression | ExpressionValue)[]);
-}
-export declare class UnaryExpression extends SPARQLExpression {
-    operator: string;
-    value: ExpressionValue;
-    readonly type = "unary_expr";
-    constructor(operator: string, value: ExpressionValue);
-}
-export declare class SelectionAliasExpression extends SPARQLExpression {
-    alias: string;
-    constructor(alias: string);
-}
-export declare class FunctionExpression extends SPARQLExpression {
-    functionName: string;
-    args: ExpressionValue[];
-    constructor(functionName: string, args: ExpressionValue[]);
-}
-export {};
-//# sourceMappingURL=expressions.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/federated/executor.d.ts

@@ -1,98 +0,0 @@
-/**
- * Federated Query Executor
- *
- * 执行跨 Pod 的联邦查询
- */
-import type { RelationDefinition } from '../schema';
-import { ProviderCache } from '../discovery/provider-cache';
-import type { FederatedResult, FederatedQueryOptions } from './types';
-/**
- * 联邦查询执行器
- */
-export declare class FederatedQueryExecutor {
-    private providerCache;
-    private fetchFn;
-    private defaultTimeout;
-    constructor(options?: {
-        providerCache?: ProviderCache;
-        fetch?: typeof fetch;
-        timeout?: number;
-    });
-    /**
-     * 执行联邦查询
-     *
-     * @param parentRows 父表的查询结果
-     * @param relationDef 关系定义
-     * @param options 查询选项
-     */
-    execute<T extends Record<string, unknown>>(parentRows: T[], relationDef: RelationDefinition, options?: FederatedQueryOptions): Promise<FederatedResult<T[]>>;
-    /**
-     * 并行执行发现和查询
-     */
-    private executeParallel;
-    /**
-     * 顺序执行发现和查询
-     */
-    private executeSequential;
-    /**
-     * 发现并查询数据
-     */
-    private discoverAndQuery;
-    /**
-     * 从 WebID 提取 Pod URL
-     */
-    private extractPodUrl;
-    /**
-     * 发现数据容器位置
-     */
-    private discoverContainer;
-    /**
-     * 从 SAI Registry 发现数据位置
-     *
-     * 简化版本：直接解析 RegistrySet -> DataRegistry -> DataRegistration
-     */
-    private discoverFromSAI;
-    /**
-     * 解析相对 URL
-     */
-    private resolveUrl;
-    /**
-     * 从 TypeIndex 发现数据位置
-     */
-    private discoverFromTypeIndex;
-    /**
-     * 查询容器中的数据
-     *
-     * 使用 LDP 获取容器内容并解析
-     */
-    private queryContainer;
-    /**
-     * 解析 Turtle 内容，提取匹配类型的资源
-     */
-    private parseTurtleResources;
-    /**
-     * 从 Turtle 中提取特定主语的所有属性
-     */
-    private extractResourceProperties;
-    /**
-     * 从 URI 提取 ID
-     *
-     * 注意：这里是 fallback 逻辑，没有 table 上下文时使用
-     * 返回包含 # 的 fragment 部分，与新的 id 规则一致
-     */
-    private extractIdFromUri;
-    /**
-     * 从 URI 提取本地名称（作为属性名）
-     */
-    private extractLocalName;
-    /**
-     * 转义正则表达式特殊字符
-     */
-    private escapeRegex;
-    /**
-     * 创建错误对象
-     */
-    private createError;
-}
-export declare const federatedQueryExecutor: FederatedQueryExecutor;
-//# sourceMappingURL=executor.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/federated/index.d.ts

@@ -1,3 +0,0 @@
-export * from './types';
-export * from './executor';
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/federated/types.d.ts

@@ -1,69 +0,0 @@
-/**
- * Federated Query Types
- *
- * 联邦查询的类型定义
- */
-import type { SolidSchema } from '../schema';
-/**
- * 联邦查询错误
- */
-export interface FederatedError {
-    /** 错误路径，如 [0, 'posts'] 表示第一个元素的 posts 字段 */
-    path: (string | number)[];
-    /** 错误代码 */
-    code: 'FORBIDDEN' | 'NOT_FOUND' | 'TIMEOUT' | 'NETWORK_ERROR' | 'DISCOVERY_FAILED';
-    /** 错误消息 */
-    message: string;
-    /** 相关的 URL（可选） */
-    url?: string;
-}
-/**
- * 联邦查询结果
- * 遵循 GraphQL 风格：data 和 errors 分开
- */
-export interface FederatedResult<T> {
-    /** 查询结果数据 */
-    data: T;
-    /** 错误列表（如果有） */
-    errors?: FederatedError[];
-}
-/**
- * 联邦查询选项
- */
-export interface FederatedQueryOptions {
-    /** 超时时间（毫秒） */
-    timeout?: number;
-    /** 是否并行查询多个 Pod */
-    parallel?: boolean;
-    /** 最大并发数 */
-    maxConcurrency?: number;
-}
-/**
- * 发现的数据位置
- */
-export interface DiscoveredLocation {
-    /** WebID 来源 */
-    webId: string;
-    /** Pod URL */
-    podUrl: string;
-    /** 数据容器 URL */
-    containerUrl: string;
-    /** 发现来源 */
-    source: 'sai' | 'typeindex';
-}
-/**
- * 联邦查询上下文
- */
-export interface FederatedQueryContext {
-    /** 父记录 */
-    parentRecord: Record<string, unknown>;
-    /** 父记录在结果中的索引 */
-    parentIndex: number;
-    /** 关系名称 */
-    relationName: string;
-    /** 目标 schema */
-    targetSchema: SolidSchema<any>;
-    /** 发现到的位置列表 */
-    locations: DiscoveredLocation[];
-}
-//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/notifications/channels/base-channel.d.ts

@@ -1,29 +0,0 @@
-import type { NotificationChannel, ChannelConfig, NotificationEvent } from '../types';
-/**
- * 解析 Activity Streams 2.0 消息为 NotificationEvent
- */
-export declare function parseActivityStreamsMessage(data: string): NotificationEvent;
-/**
- * Channel 抽象基类
- */
-export declare abstract class BaseChannel implements NotificationChannel {
-    protected _connected: boolean;
-    protected readonly config: ChannelConfig;
-    constructor(config: ChannelConfig);
-    get connected(): boolean;
-    abstract connect(): Promise<void>;
-    abstract disconnect(): void;
-    /**
-     * 处理收到的消息
-     */
-    protected handleMessage(data: string): void;
-    /**
-     * 处理错误
-     */
-    protected handleError(error: Error): void;
-    /**
-     * 处理连接关闭
-     */
-    protected handleClose(): void;
-}
-//# sourceMappingURL=base-channel.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/notifications/channels/index.d.ts

@@ -1,4 +0,0 @@
-export { BaseChannel, parseActivityStreamsMessage } from './base-channel';
-export { SSEChannel } from './sse-channel';
-export { WebSocketChannel } from './websocket-channel';
-//# sourceMappingURL=index.d.ts.map