@extasyio/market-models/dist/index.js

Typed market data models (Trade, OrderBookSnapshot, MarketTick) with Zod validation and MsgPack/JSON serialization

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], 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/index.ts
var index_exports = {};
__export(index_exports, {
  MarketTickSchema: () => MarketTickSchema,
  OrderBookSnapshotSchema: () => OrderBookSnapshotSchema,
  OrderSide: () => OrderSide,
  TimeFrame: () => TimeFrame,
  TradeSchema: () => TradeSchema,
  decodeOrderBook: () => decodeOrderBook,
  decodeTick: () => decodeTick,
  decodeTrade: () => decodeTrade,
  encodeOrderBook: () => encodeOrderBook,
  encodeTick: () => encodeTick,
  encodeTrade: () => encodeTrade,
  fromMsgPack: () => fromMsgPack,
  toMsgPack: () => toMsgPack
});
module.exports = __toCommonJS(index_exports);

// src/enums.ts
var OrderSide = /* @__PURE__ */ ((OrderSide2) => {
  OrderSide2["Buy"] = "buy";
  OrderSide2["Sell"] = "sell";
  return OrderSide2;
})(OrderSide || {});
var TimeFrame = /* @__PURE__ */ ((TimeFrame2) => {
  TimeFrame2["M1"] = "1m";
  TimeFrame2["M5"] = "5m";
  TimeFrame2["M15"] = "15m";
  TimeFrame2["H1"] = "1h";
  TimeFrame2["D1"] = "1d";
  return TimeFrame2;
})(TimeFrame || {});

// src/trade.ts
var import_zod = require("zod");
var TradeSchema = import_zod.z.object({
  price: import_zod.z.number().positive(),
  amount: import_zod.z.number().positive(),
  side: import_zod.z.nativeEnum(OrderSide),
  ts: import_zod.z.number().int().nonnegative()
  // unix-ms
});

// src/order-book.ts
var import_zod2 = require("zod");
var BookLevel = import_zod2.z.tuple([import_zod2.z.number().positive(), import_zod2.z.number().positive()]);
var OrderBookSnapshotSchema = import_zod2.z.object({
  ts: import_zod2.z.number().int().nonnegative(),
  bids: import_zod2.z.array(BookLevel),
  asks: import_zod2.z.array(BookLevel)
});

// src/market-tick.ts
var import_zod3 = require("zod");
var MarketTickSchema = import_zod3.z.object({
  tf: import_zod3.z.nativeEnum(TimeFrame),
  open: import_zod3.z.number(),
  high: import_zod3.z.number(),
  low: import_zod3.z.number(),
  close: import_zod3.z.number(),
  volume: import_zod3.z.number().nonnegative(),
  tsOpen: import_zod3.z.number().int().nonnegative()
});

// src/serde.ts
var import_msgpackr = require("msgpackr");
var encoder = new import_msgpackr.Encoder();
var decoder = new import_msgpackr.Decoder();
var toMsgPack = (value) => encoder.encode(value);
var fromMsgPack = (buf) => decoder.decode(buf);
var encodeTrade = (t) => toMsgPack(t);
var decodeTrade = (buf) => TradeSchema.parse(fromMsgPack(buf));
var encodeOrderBook = (ob) => toMsgPack(ob);
var decodeOrderBook = (buf) => OrderBookSnapshotSchema.parse(fromMsgPack(buf));
var encodeTick = (c) => toMsgPack(c);
var decodeTick = (buf) => MarketTickSchema.parse(fromMsgPack(buf));
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  MarketTickSchema,
  OrderBookSnapshotSchema,
  OrderSide,
  TimeFrame,
  TradeSchema,
  decodeOrderBook,
  decodeTick,
  decodeTrade,
  encodeOrderBook,
  encodeTick,
  encodeTrade,
  fromMsgPack,
  toMsgPack
});