lemon-model 1.1.1 → 1.2.1

package/dist/socket/index.js

@@ -0,0 +1,29 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `socket/index.ts`
+ * - shared socket(network) + json-transport core for F/B usage.
+ *
+ * @copyright (C) 2026 LemonCloud Co Ltd. - All Rights Reserved.
+ */
+__exportStar(require("./types"), exports);
+__exportStar(require("./transport"), exports);
+__exportStar(require("./websocket"), exports);
+//! NOTE: the in-memory peer simulator (`./socket`) is intentionally NOT re-exported here.
+//! It is a test/dev utility — import it via the isolated `lemon-model/socket/testing` entry
+//! so production (esp. frontend) bundles do not pull in the simulator runtime.
+//# sourceMappingURL=index.js.map

package/dist/socket/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/socket/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;GAKG;AACH,0CAAwB;AACxB,8CAA4B;AAC5B,8CAA4B;AAE5B,0FAA0F;AAC1F,4FAA4F;AAC5F,+EAA+E"}

package/dist/socket/socket.d.ts

@@ -0,0 +1,191 @@
+/**
+ * `socket/socket.ts`
+ * - in-memory peer WebSocket simulator.
+ *
+ * @copyright (C) 2026 LemonCloud Co Ltd. - All Rights Reserved.
+ */
+import { NetworkMessageHandler, NetworkSupportable, PeerMessageHandler, PeerSupportable, PeerTargetOptions, SocketErrorHandler, SocketLogger, SocketNetworkOptions, SocketMessage, SocketReadyState, SocketUnsubscribe } from './types';
+import { JSONTransportOptions } from './transport';
+/** options for simulated peers */
+export interface PeerOptions extends SocketNetworkOptions {
+    /** peer id */
+    id?: string;
+    /** id generator used by peers, peer links, and auto message ids */
+    identityProvider?: PeerIdentityProvider;
+    /** network factory used by peer connect/reconnect */
+    networkFactory?: PeerNetworkFactory;
+    /** structured logger for peer lifecycle and delivery events */
+    logger?: SocketLogger;
+    /** enable JSON transport chunking for peer message envelopes sent by this peer */
+    jsonTransport?: boolean | JSONTransportOptions;
+}
+/** network creation context independent from peer instances. */
+export interface PeerNetworkFactoryContext {
+    /** generated network id */
+    id: string;
+    /** sending peer id */
+    fromPeerId: string;
+    /** receiving peer id */
+    toPeerId: string;
+    /** resolved network behavior options */
+    options: Required<SocketNetworkOptions>;
+    /** logger propagated from the creating peer */
+    logger?: SocketLogger;
+}
+/** factory for creating peer link networks. */
+export interface PeerNetworkFactory {
+    (context: PeerNetworkFactoryContext): NetworkSupportable;
+}
+/** id generator for deterministic peer tests and custom runtimes. */
+export interface PeerIdentityProvider {
+    /** generate peer id */
+    nextPeerId(): string;
+    /** generate client id assigned by the accepting peer */
+    nextClientId(): string;
+    /** generate message id for peer.send() */
+    nextMessageId(): string;
+    /** generate network id; peer ids are provided for link networks */
+    nextNetworkId(fromPeerId?: string, toPeerId?: string): string;
+}
+/** options for socket factory */
+export interface SocketFactoryOptions extends PeerOptions {
+    /** prefix used when auto-generating peer ids */
+    idPrefix?: string;
+}
+export declare const defaultPeerIdentityProvider: PeerIdentityProvider;
+export declare const nextMessageId: () => string;
+export declare const defaultPeerNetworkFactory: PeerNetworkFactory;
+export declare const noopSocketLogger: SocketLogger;
+export interface NetworkOptions extends SocketNetworkOptions {
+    id?: string;
+    fromPeerId?: string;
+    toPeerId?: string;
+    logger?: SocketLogger;
+}
+/**
+ * one-shot in-memory network transport.
+ * - public transport surface is intentionally limited to send(string) and close().
+ */
+export declare class Network implements NetworkSupportable {
+    readonly id: string;
+    private state;
+    private readonly messageListeners;
+    private used;
+    private options;
+    private deliveryNo;
+    private readonly errorListeners;
+    private readonly fromPeerId?;
+    private readonly toPeerId?;
+    private readonly logger;
+    constructor(options?: NetworkOptions);
+    /** network state */
+    get readyState(): SocketReadyState;
+    /** wait until this in-memory network is ready */
+    ready(): Promise<void>;
+    /** attach this network to exactly one receiver */
+    attach(receiver: NetworkMessageHandler): void;
+    /** send raw string data over the network */
+    send(data: string): void;
+    /** subscribe to raw string data delivered from the network */
+    onMessage(handler: NetworkMessageHandler): SocketUnsubscribe;
+    /** update network conditions */
+    configure(options: SocketNetworkOptions): void;
+    /** observe asynchronous network delivery errors */
+    onError(handler: SocketErrorHandler): SocketUnsubscribe;
+    /** close this network forever */
+    close(): void;
+    private ensureOpen;
+    private nextDeliveryDelayMs;
+    private emitError;
+    private log;
+}
+/** create a one-shot network */
+export declare const createNetwork: (options?: NetworkOptions) => Network;
+/**
+ * in-memory peer that can act as a server, a client, or both.
+ */
+export declare class Peer<SendData = any, MessageData = any> implements PeerSupportable<SendData, MessageData> {
+    readonly id: string;
+    private assignedClientId?;
+    private state;
+    private server?;
+    private readonly clients;
+    private readonly listeners;
+    private readonly errorListeners;
+    private readonly pending;
+    private networkOptions;
+    private identityProvider;
+    private networkFactory;
+    private logger;
+    private jsonTransportOptions?;
+    constructor(options?: PeerOptions);
+    /** assigned client id when this peer is connected to another peer */
+    get clientId(): string | undefined;
+    /** endpoint state */
+    get readyState(): SocketReadyState;
+    /** upstream network when this peer is connected as a client */
+    get network(): NetworkSupportable | undefined;
+    /** wait until this peer's upstream network is ready */
+    ready(): Promise<void>;
+    /** update network conditions for this peer and connected networks */
+    configureNetwork(options: SocketNetworkOptions): void;
+    /** connect this peer as a client to a server peer */
+    connect(peer: PeerSupportable<MessageData, SendData>): string;
+    /** replace connected network instances while keeping the peer relationship */
+    reconnect(options?: PeerTargetOptions): string;
+    /** find a client peer connected to this peer by client id */
+    findPeer<T extends PeerSupportable<any, any> = PeerSupportable<any, any>>(clientId: string): T | undefined;
+    /** post a typed message without waiting for a result */
+    post(message: SocketMessage<SendData>, options?: PeerTargetOptions): void;
+    /** send a typed message and wait for a result message with the same mid */
+    send<R = any>(message: Omit<SocketMessage<SendData>, 'mid'> & {
+        mid?: string;
+    }, options?: PeerTargetOptions): Promise<R>;
+    /** subscribe to incoming messages */
+    onMessage<T = MessageData, R = any>(handler: PeerMessageHandler<T, R>): SocketUnsubscribe;
+    /** observe fire-and-forget transport errors */
+    onError(handler: SocketErrorHandler): SocketUnsubscribe;
+    /** close this peer */
+    close(): void;
+    private accept;
+    private attachClientReceiverTransport;
+    private detachClient;
+    private closeLink;
+    private static reconnectPair;
+    private static attachReceiver;
+    private createPeerNetwork;
+    private static createNetworkPair;
+    private publish;
+    private resolveTarget;
+    private receiveNetworkData;
+    private dispatch;
+    private reply;
+    private sendToLink;
+    private findLinkTo;
+    private rejectPending;
+    private emitError;
+    private ensureOpen;
+    private log;
+}
+/** create a peer */
+export declare const createPeer: <SendData = any, MessageData = any>(options?: PeerOptions) => Peer<SendData, MessageData>;
+/**
+ * factory for creating peers and keeping a small registry for tests.
+ */
+export declare class SocketFactory {
+    private readonly options?;
+    private no;
+    private readonly peers;
+    constructor(options?: SocketFactoryOptions);
+    /** create and register a peer */
+    peer<SendData = any, MessageData = any>(options?: PeerOptions): Peer<SendData, MessageData>;
+    /** find a registered peer by peer id */
+    find<T extends PeerSupportable<any, any> = PeerSupportable<any, any>>(id: string): T | undefined;
+    /** connect client to server and return the assigned client id */
+    connect(client: PeerSupportable<any, any>, server: PeerSupportable<any, any>): string;
+    /** find a client peer connected to a server peer by client id */
+    findPeer<T extends PeerSupportable<any, any> = PeerSupportable<any, any>>(server: PeerSupportable<any, any>, clientId: string): T | undefined;
+    private nextFactoryPeerId;
+}
+/** create a socket factory */
+export declare const createSocketFactory: (options?: SocketFactoryOptions) => SocketFactory;