@hotlap.ai/telemetry 1.0.0 → 1.1.0

package/dist/ibt.js

@@ -1,298 +1,15 @@
 // @bun
 import {
-  $parse
-} from "./index-k5bgtn4c.js";
-import {
-  parseDiskSubHeader,
-  parseHeader,
-  parseVarHeaders,
-  readString,
-  readVarValue,
-  readVarValueBatch
-} from "./binary-reader.js";
-import {
-  DISK_SUB_HEADER_OFFSET
-} from "./constants.js";
-
-// src/ibt.ts
-class IBT {
-  buffer = null;
-  view = null;
-  header = null;
-  diskHeader = null;
-  varHeaders = null;
-  sessionInfoCache = new Map;
-  rawSessionInfo = null;
-  filePath = null;
-  get fileName() {
-    return this.filePath;
-  }
-  get varHeaderBufferTick() {
-    return this.header?.varBuf[0]?.tickCount ?? null;
-  }
-  get varHeaderNames() {
-    if (!this.varHeaders)
-      return null;
-    return Array.from(this.varHeaders.keys());
-  }
-  get recordCount() {
-    return this.diskHeader?.sessionRecordCount ?? 0;
-  }
-  get sessionLapCount() {
-    return this.diskHeader?.sessionLapCount ?? 0;
-  }
-  get sessionStartTime() {
-    return this.diskHeader?.sessionStartTime ?? 0;
-  }
-  get sessionEndTime() {
-    return this.diskHeader?.sessionEndTime ?? 0;
-  }
-  get tickRate() {
-    return this.header?.tickRate ?? 60;
-  }
-  get bufLen() {
-    return this.header?.bufLen ?? 0;
-  }
-  async open(filePath) {
-    this.filePath = filePath;
-    const file = Bun.file(filePath);
-    const arrayBuffer = await file.arrayBuffer();
-    this.buffer = new Uint8Array(arrayBuffer);
-    this.view = new DataView(arrayBuffer);
-    this.header = parseHeader(this.view);
-    this.diskHeader = parseDiskSubHeader(this.view, DISK_SUB_HEADER_OFFSET);
-    this.varHeaders = parseVarHeaders(this.view, this.buffer, this.header);
-    this.sessionInfoCache.clear();
-    this.rawSessionInfo = null;
-  }
-  openSync(filePath) {
-    this.filePath = filePath;
-    const file = Bun.file(filePath);
-    const arrayBuffer = file.arrayBuffer();
-    if (arrayBuffer instanceof Promise) {
-      throw new Error("Sync file reading requires Bun.file().bytes() - use open() instead");
-    }
-    this.buffer = new Uint8Array(arrayBuffer);
-    this.view = new DataView(arrayBuffer);
-    this.header = parseHeader(this.view);
-    this.diskHeader = parseDiskSubHeader(this.view, DISK_SUB_HEADER_OFFSET);
-    this.varHeaders = parseVarHeaders(this.view, this.buffer, this.header);
-    this.sessionInfoCache.clear();
-    this.rawSessionInfo = null;
-  }
-  static async fromBuffer(buffer) {
-    const ibt = new IBT;
-    ibt.buffer = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-    ibt.view = new DataView(ibt.buffer.buffer, ibt.buffer.byteOffset, ibt.buffer.byteLength);
-    ibt.header = parseHeader(ibt.view);
-    ibt.diskHeader = parseDiskSubHeader(ibt.view, DISK_SUB_HEADER_OFFSET);
-    ibt.varHeaders = parseVarHeaders(ibt.view, ibt.buffer, ibt.header);
-    return ibt;
-  }
-  close() {
-    this.buffer = null;
-    this.view = null;
-    this.header = null;
-    this.diskHeader = null;
-    this.varHeaders = null;
-    this.sessionInfoCache.clear();
-    this.rawSessionInfo = null;
-    this.filePath = null;
-  }
-  getVarHeader(name) {
-    return this.varHeaders?.get(name);
-  }
-  get(index, key) {
-    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
-      return null;
-    if (index < 0 || index >= this.diskHeader.sessionRecordCount)
-      return null;
-    const varHeader = this.varHeaders.get(key);
-    if (!varHeader)
-      return null;
-    const varBuf = this.header.varBuf[0];
-    if (!varBuf)
-      return null;
-    const varOffset = varHeader.offset + varBuf.bufOffset + index * this.header.bufLen;
-    return readVarValue(this.view, varOffset, varHeader.type, varHeader.count);
-  }
-  getAll(key) {
-    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
-      return null;
-    const varHeader = this.varHeaders.get(key);
-    if (!varHeader)
-      return null;
-    const varBuf = this.header.varBuf[0];
-    if (!varBuf)
-      return null;
-    const baseOffset = varBuf.bufOffset;
-    const bufLen = this.header.bufLen;
-    const recordCount = this.diskHeader.sessionRecordCount;
-    const varOffset = varHeader.offset;
-    const isArray = varHeader.count > 1;
-    const results = new Array(recordCount);
-    for (let i = 0;i < recordCount; i++) {
-      const offset = baseOffset + i * bufLen + varOffset;
-      results[i] = readVarValue(this.view, offset, varHeader.type, varHeader.count);
-    }
-    return results;
-  }
-  getAllTyped(key) {
-    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
-      return null;
-    const varHeader = this.varHeaders.get(key);
-    if (!varHeader || varHeader.count !== 1)
-      return null;
-    const varBuf = this.header.varBuf[0];
-    if (!varBuf)
-      return null;
-    const baseOffset = varBuf.bufOffset;
-    const bufLen = this.header.bufLen;
-    const recordCount = this.diskHeader.sessionRecordCount;
-    const varOffset = varHeader.offset;
-    let output;
-    switch (varHeader.type) {
-      case 4:
-        output = new Float32Array(recordCount);
-        break;
-      case 5:
-        output = new Float64Array(recordCount);
-        break;
-      case 2:
-        output = new Int32Array(recordCount);
-        break;
-      case 3:
-        output = new Uint32Array(recordCount);
-        break;
-      default:
-        return null;
-    }
-    readVarValueBatch(this.view, baseOffset, varOffset, varHeader.type, bufLen, recordCount, output);
-    return output;
-  }
-  getAllMultiple(keys) {
-    const results = new Map;
-    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
-      return results;
-    const varBuf = this.header.varBuf[0];
-    if (!varBuf)
-      return results;
-    const baseOffset = varBuf.bufOffset;
-    const bufLen = this.header.bufLen;
-    const recordCount = this.diskHeader.sessionRecordCount;
-    const varInfos = [];
-    for (const key of keys) {
-      const varHeader = this.varHeaders.get(key);
-      if (varHeader) {
-        const data = new Array(recordCount);
-        varInfos.push({ key, varHeader, data });
-        results.set(key, data);
-      }
-    }
-    for (let i = 0;i < recordCount; i++) {
-      const recordOffset = baseOffset + i * bufLen;
-      for (const { varHeader, data } of varInfos) {
-        const offset = recordOffset + varHeader.offset;
-        data[i] = readVarValue(this.view, offset, varHeader.type, varHeader.count);
-      }
-    }
-    return results;
-  }
-  *iterate(keys) {
-    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
-      return;
-    const varBuf = this.header.varBuf[0];
-    if (!varBuf)
-      return;
-    const baseOffset = varBuf.bufOffset;
-    const bufLen = this.header.bufLen;
-    const recordCount = this.diskHeader.sessionRecordCount;
-    const varInfos = [];
-    for (const key of keys) {
-      const varHeader = this.varHeaders.get(key);
-      if (varHeader) {
-        varInfos.push({ key, varHeader });
-      }
-    }
-    for (let i = 0;i < recordCount; i++) {
-      const recordOffset = baseOffset + i * bufLen;
-      const record = new Map;
-      for (const { key, varHeader } of varInfos) {
-        const offset = recordOffset + varHeader.offset;
-        record.set(key, readVarValue(this.view, offset, varHeader.type, varHeader.count));
-      }
-      yield record;
-    }
-  }
-  getRawSessionInfo() {
-    if (!this.header || !this.buffer)
-      return null;
-    if (this.rawSessionInfo === null) {
-      const start = this.header.sessionInfoOffset;
-      const len = this.header.sessionInfoLen;
-      this.rawSessionInfo = readString(this.buffer, start, len);
-    }
-    return this.rawSessionInfo;
-  }
-  getSessionInfo(key) {
-    const raw = this.getRawSessionInfo();
-    if (!raw)
-      return null;
-    if (!key) {
-      if (!this.sessionInfoCache.has("__full__")) {
-        try {
-          const cleaned = this.cleanYaml(raw);
-          this.sessionInfoCache.set("__full__", $parse(cleaned));
-        } catch {
-          return null;
-        }
-      }
-      return this.sessionInfoCache.get("__full__");
-    }
-    if (this.sessionInfoCache.has(key)) {
-      return this.sessionInfoCache.get(key);
-    }
-    const sectionMatch = raw.match(new RegExp(`
-${key}:
-([\\s\\S]*?)(?=
-
-|$)`));
-    if (!sectionMatch)
-      return null;
-    try {
-      const sectionYaml = `${key}:
-${sectionMatch[1]}`;
-      const cleaned = this.cleanYaml(sectionYaml);
-      const parsed = $parse(cleaned);
-      const result = parsed?.[key] ?? null;
-      this.sessionInfoCache.set(key, result);
-      return result;
-    } catch {
-      return null;
-    }
-  }
-  cleanYaml(yaml) {
-    let cleaned = yaml.replace(/[\x81\x8D\x8F\x90\x9D]/g, " ").replace(/[^\x09\x0A\x0D\x20-\x7E\xA0-\xFF]/g, "");
-    cleaned = cleaned.replace(/((?:DriverSetupName|UserName|TeamName|AbbrevName|Initials): )(.*)/g, (_, prefix, value) => {
-      const escaped = value.replace(/["\\]/g, "\\$&");
-      return `${prefix}"${escaped}"`;
-    });
-    cleaned = cleaned.replace(/(\w+: )(,.*)/g, '$1"$2"');
-    return cleaned;
-  }
-}
-async function parseIbt(filePath) {
-  const ibt = new IBT;
-  await ibt.open(filePath);
-  return ibt;
-}
-async function parseIbtBuffer(buffer) {
-  return IBT.fromBuffer(buffer);
-}
+  IBT,
+  parseIbt,
+  parseIbtBuffer
+} from "./index-tz5ph8p3.js";
+import"./index-hxw291vy.js";
+import"./index-c5jf6rjt.js";
+import"./index-wb6ebd0j.js";
+import"./index-ftpvnye9.js";
 export {
   parseIbtBuffer,
   parseIbt,
   IBT
 };
-
-export { IBT, parseIbt, parseIbtBuffer };

package/dist/index-c5jf6rjt.js

@@ -0,0 +1,189 @@
+// @bun
+import {
+  VAR_TYPE_SIZES
+} from "./index-wb6ebd0j.js";
+
+// src/binary-reader.ts
+var textDecoder = new TextDecoder;
+function readInt32LE(view, offset) {
+  return view.getInt32(offset, true);
+}
+function readUint32LE(view, offset) {
+  return view.getUint32(offset, true);
+}
+function readFloat32LE(view, offset) {
+  return view.getFloat32(offset, true);
+}
+function readFloat64LE(view, offset) {
+  return view.getFloat64(offset, true);
+}
+function readBigUint64LE(view, offset) {
+  return view.getBigUint64(offset, true);
+}
+function readBoolLE(view, offset) {
+  return view.getUint8(offset) !== 0;
+}
+function readCharLE(view, offset) {
+  return view.getInt8(offset);
+}
+function readString(buffer, offset, length) {
+  let end = offset;
+  const maxEnd = offset + length;
+  while (end < maxEnd && buffer[end] !== 0)
+    end++;
+  return textDecoder.decode(buffer.subarray(offset, end));
+}
+function readVarValue(view, offset, type, count) {
+  const size = VAR_TYPE_SIZES[type];
+  if (count === 1) {
+    switch (type) {
+      case 0:
+        return readCharLE(view, offset);
+      case 1:
+        return readBoolLE(view, offset);
+      case 2:
+        return readInt32LE(view, offset);
+      case 3:
+        return readUint32LE(view, offset);
+      case 4:
+        return readFloat32LE(view, offset);
+      case 5:
+        return readFloat64LE(view, offset);
+    }
+  }
+  if (type === 1) {
+    const result2 = new Array(count);
+    for (let i = 0;i < count; i++) {
+      result2[i] = readBoolLE(view, offset + i);
+    }
+    return result2;
+  }
+  const result = new Array(count);
+  for (let i = 0;i < count; i++) {
+    const pos = offset + i * size;
+    switch (type) {
+      case 0:
+        result[i] = readCharLE(view, pos);
+        break;
+      case 2:
+        result[i] = readInt32LE(view, pos);
+        break;
+      case 3:
+        result[i] = readUint32LE(view, pos);
+        break;
+      case 4:
+        result[i] = readFloat32LE(view, pos);
+        break;
+      case 5:
+        result[i] = readFloat64LE(view, pos);
+        break;
+    }
+  }
+  return result;
+}
+function readVarValueBatch(view, baseOffset, varOffset, type, bufLen, recordCount, output) {
+  const size = VAR_TYPE_SIZES[type];
+  let writeIdx = 0;
+  switch (type) {
+    case 4:
+      for (let i = 0;i < recordCount; i++) {
+        output[writeIdx++] = view.getFloat32(baseOffset + i * bufLen + varOffset, true);
+      }
+      break;
+    case 5:
+      for (let i = 0;i < recordCount; i++) {
+        output[writeIdx++] = view.getFloat64(baseOffset + i * bufLen + varOffset, true);
+      }
+      break;
+    case 2:
+      for (let i = 0;i < recordCount; i++) {
+        output[writeIdx++] = view.getInt32(baseOffset + i * bufLen + varOffset, true);
+      }
+      break;
+    case 3:
+      for (let i = 0;i < recordCount; i++) {
+        output[writeIdx++] = view.getUint32(baseOffset + i * bufLen + varOffset, true);
+      }
+      break;
+  }
+}
+function parseHeader(view) {
+  const version = readInt32LE(view, 0);
+  const status = readInt32LE(view, 4);
+  const tickRate = readInt32LE(view, 8);
+  const sessionInfoUpdate = readInt32LE(view, 12);
+  const sessionInfoLen = readInt32LE(view, 16);
+  const sessionInfoOffset = readInt32LE(view, 20);
+  const numVars = readInt32LE(view, 24);
+  const varHeaderOffset = readInt32LE(view, 28);
+  const numBuf = readInt32LE(view, 32);
+  const bufLen = readInt32LE(view, 36);
+  const varBuf = new Array(numBuf);
+  for (let i = 0;i < numBuf; i++) {
+    const offset = 48 + i * 16;
+    varBuf[i] = {
+      tickCount: readInt32LE(view, offset),
+      bufOffset: readInt32LE(view, offset + 4)
+    };
+  }
+  return {
+    version,
+    status,
+    tickRate,
+    sessionInfoUpdate,
+    sessionInfoLen,
+    sessionInfoOffset,
+    numVars,
+    varHeaderOffset,
+    numBuf,
+    bufLen,
+    varBuf
+  };
+}
+function parseVarHeader(view, buffer, offset) {
+  return {
+    type: readInt32LE(view, offset),
+    offset: readInt32LE(view, offset + 4),
+    count: readInt32LE(view, offset + 8),
+    countAsTime: readBoolLE(view, offset + 12),
+    name: readString(buffer, offset + 16, 32),
+    desc: readString(buffer, offset + 48, 64),
+    unit: readString(buffer, offset + 112, 32)
+  };
+}
+function parseDiskSubHeader(view, offset) {
+  return {
+    sessionStartDate: readBigUint64LE(view, offset),
+    sessionStartTime: readFloat64LE(view, offset + 8),
+    sessionEndTime: readFloat64LE(view, offset + 16),
+    sessionLapCount: readInt32LE(view, offset + 24),
+    sessionRecordCount: readInt32LE(view, offset + 28)
+  };
+}
+function parseVarHeaders(view, buffer, header) {
+  const headers = new Map;
+  for (let i = 0;i < header.numVars; i++) {
+    const varHeader = parseVarHeader(view, buffer, header.varHeaderOffset + i * 144);
+    headers.set(varHeader.name, varHeader);
+  }
+  return headers;
+}
+function getLatestVarBuffer(varBufs) {
+  if (varBufs.length === 0) {
+    throw new Error("varBufs array is empty");
+  }
+  let latest = varBufs[0];
+  let secondLatest = varBufs[1] ?? varBufs[0];
+  for (let i = 1;i < varBufs.length; i++) {
+    const current = varBufs[i];
+    if (current.tickCount > latest.tickCount) {
+      secondLatest = latest;
+      latest = current;
+    } else if (current.tickCount > secondLatest.tickCount) {
+      secondLatest = current;
+    }
+  }
+  return secondLatest;
+}
+
+export { readInt32LE, readUint32LE, readFloat32LE, readFloat64LE, readBigUint64LE, readBoolLE, readCharLE, readString, readVarValue, readVarValueBatch, parseHeader, parseVarHeader, parseDiskSubHeader, parseVarHeaders, getLatestVarBuffer };

package/dist/index-ftpvnye9.js

@@ -0,0 +1,5 @@
+// @bun
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+export { __commonJS, __require };

package/dist/{index-k5bgtn4c.js → index-hxw291vy.js}

@@ -2,7 +2,7 @@
 import {
   __commonJS,
   __require
-} from "./constants.js";
+} from "./index-ftpvnye9.js";
 
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS((exports) => {