@basmilius/apple-encoding 0.5.4 → 0.6.0

package/dist/daap.d.ts

@@ -0,0 +1,95 @@
+export declare const ContentCode: {
+	readonly mlit: "dmap.listingitem";
+	readonly mlcl: "dmap.listing";
+	readonly msrv: "dmap.serverinforesponse";
+	readonly mcon: "dmap.container";
+	readonly miid: "dmap.itemid";
+	readonly minm: "dmap.itemname";
+	readonly mikd: "dmap.itemkind";
+	readonly mper: "dmap.persistentid";
+	readonly asal: "daap.songalbum";
+	readonly asar: "daap.songartist";
+	readonly asaa: "daap.songalbumartist";
+	readonly ascp: "daap.songcomposer";
+	readonly asgn: "daap.songgenre";
+	readonly astm: "daap.songtime";
+	readonly astn: "daap.songtracknumber";
+	readonly asdc: "daap.songdisccount";
+	readonly asdn: "daap.songdiscnumber";
+	readonly astc: "daap.songtrackcount";
+	readonly asyr: "daap.songyear";
+	readonly asbr: "daap.songbitrate";
+	readonly assr: "daap.songsamplerate";
+	readonly assz: "daap.songsize";
+	readonly caps: "daap.songplaystatus";
+	readonly cash: "daap.songshufflestate";
+	readonly carp: "daap.songrepeatstate";
+	readonly cavs: "daap.songvisiblestate";
+	readonly aePP: "com.apple.itunes.photo-properties";
+};
+export declare const TagType: {
+	readonly mlit: 12;
+	readonly mlcl: 12;
+	readonly mcon: 12;
+	readonly msrv: 12;
+	readonly miid: 5;
+	readonly minm: 9;
+	readonly mikd: 1;
+	readonly mper: 7;
+	readonly asal: 9;
+	readonly asar: 9;
+	readonly asaa: 9;
+	readonly ascp: 9;
+	readonly asgn: 9;
+	readonly astm: 5;
+	readonly astn: 3;
+	readonly asdc: 3;
+	readonly asdn: 3;
+	readonly astc: 3;
+	readonly asyr: 3;
+	readonly asbr: 3;
+	readonly assr: 5;
+	readonly assz: 5;
+	readonly caps: 1;
+	readonly cash: 1;
+	readonly carp: 1;
+	readonly cavs: 1;
+	readonly aePP: 9;
+};
+export declare function encodeTag(tag: string, value: Buffer | string | number | bigint): Buffer;
+export declare function encodeContainer(tag: string, content: Buffer): Buffer;
+export declare function encodePlaybackStatus(status: PlaybackStatus): Buffer;
+export declare function encodeTagWithSize(tag: string, value: number, byteSize: 1 | 2 | 4 | 8): Buffer;
+export declare function encodeTrackMetadata(metadata: TrackMetadata): Buffer;
+export declare function decode(buffer: Buffer): DecodedTag[];
+export declare function decodeTag(buffer: Buffer): [DecodedTag, Buffer] | null;
+export declare function decodeToObject(buffer: Buffer): Record<string, unknown>;
+export declare function decodeTrackMetadata(buffer: Buffer): TrackMetadata;
+export type ContentCodeKey = keyof typeof ContentCode;
+export type DecodedTag = {
+	readonly tag: string;
+	readonly length: number;
+	readonly value: Buffer;
+};
+export type PlaybackStatus = {
+	readonly playing?: boolean;
+	readonly shuffle?: boolean;
+	readonly repeat?: "off" | "one" | "all";
+};
+export type TrackMetadata = {
+	readonly title?: string;
+	readonly artist?: string;
+	readonly albumArtist?: string;
+	readonly album?: string;
+	readonly composer?: string;
+	readonly genre?: string;
+	readonly duration?: number;
+	readonly trackNumber?: number;
+	readonly trackCount?: number;
+	readonly discNumber?: number;
+	readonly discCount?: number;
+	readonly year?: number;
+	readonly bitrate?: number;
+	readonly sampleRate?: number;
+	readonly size?: number;
+};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * as DAAP from "./daap";
 export * as NTP from "./ntp";
 export * as OPack from "./opack";
 export * as Plist from "./plist";

package/dist/index.js

@@ -9,6 +9,284 @@ var __export = (target, all) => {
     });
 };
 
+// src/daap.ts
+var exports_daap = {};
+__export(exports_daap, {
+  encodeTrackMetadata: () => encodeTrackMetadata,
+  encodeTagWithSize: () => encodeTagWithSize,
+  encodeTag: () => encodeTag,
+  encodePlaybackStatus: () => encodePlaybackStatus,
+  encodeContainer: () => encodeContainer,
+  decodeTrackMetadata: () => decodeTrackMetadata,
+  decodeToObject: () => decodeToObject,
+  decodeTag: () => decodeTag,
+  decode: () => decode,
+  TagType: () => TagType,
+  ContentCode: () => ContentCode
+});
+var ContentCode = {
+  mlit: "dmap.listingitem",
+  mlcl: "dmap.listing",
+  msrv: "dmap.serverinforesponse",
+  mcon: "dmap.container",
+  miid: "dmap.itemid",
+  minm: "dmap.itemname",
+  mikd: "dmap.itemkind",
+  mper: "dmap.persistentid",
+  asal: "daap.songalbum",
+  asar: "daap.songartist",
+  asaa: "daap.songalbumartist",
+  ascp: "daap.songcomposer",
+  asgn: "daap.songgenre",
+  astm: "daap.songtime",
+  astn: "daap.songtracknumber",
+  asdc: "daap.songdisccount",
+  asdn: "daap.songdiscnumber",
+  astc: "daap.songtrackcount",
+  asyr: "daap.songyear",
+  asbr: "daap.songbitrate",
+  assr: "daap.songsamplerate",
+  assz: "daap.songsize",
+  caps: "daap.songplaystatus",
+  cash: "daap.songshufflestate",
+  carp: "daap.songrepeatstate",
+  cavs: "daap.songvisiblestate",
+  aePP: "com.apple.itunes.photo-properties"
+};
+var TagType = {
+  mlit: 12,
+  mlcl: 12,
+  mcon: 12,
+  msrv: 12,
+  miid: 5,
+  minm: 9,
+  mikd: 1,
+  mper: 7,
+  asal: 9,
+  asar: 9,
+  asaa: 9,
+  ascp: 9,
+  asgn: 9,
+  astm: 5,
+  astn: 3,
+  asdc: 3,
+  asdn: 3,
+  astc: 3,
+  asyr: 3,
+  asbr: 3,
+  assr: 5,
+  assz: 5,
+  caps: 1,
+  cash: 1,
+  carp: 1,
+  cavs: 1,
+  aePP: 9
+};
+function encodeTag(tag, value) {
+  if (tag.length !== 4) {
+    throw new Error(`Invalid DAAP tag: ${tag}. Tags must be exactly 4 characters.`);
+  }
+  const tagBuffer = Buffer.from(tag, "ascii");
+  let valueBuffer;
+  if (typeof value === "string") {
+    valueBuffer = Buffer.from(value, "utf8");
+  } else if (typeof value === "bigint") {
+    valueBuffer = Buffer.alloc(8);
+    valueBuffer.writeBigUInt64BE(value, 0);
+  } else if (typeof value === "number") {
+    if (value <= 255 && value >= 0) {
+      valueBuffer = Buffer.alloc(1);
+      valueBuffer.writeUInt8(value, 0);
+    } else if (value <= 65535 && value >= 0) {
+      valueBuffer = Buffer.alloc(2);
+      valueBuffer.writeUInt16BE(value, 0);
+    } else if (value <= 4294967295 && value >= 0) {
+      valueBuffer = Buffer.alloc(4);
+      valueBuffer.writeUInt32BE(value, 0);
+    } else {
+      valueBuffer = Buffer.alloc(8);
+      valueBuffer.writeBigInt64BE(BigInt(value), 0);
+    }
+  } else {
+    valueBuffer = value;
+  }
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32BE(valueBuffer.length, 0);
+  return Buffer.concat([tagBuffer, lengthBuffer, valueBuffer]);
+}
+function encodeContainer(tag, content) {
+  if (tag.length !== 4) {
+    throw new Error(`Invalid DAAP tag: ${tag}. Tags must be exactly 4 characters.`);
+  }
+  const tagBuffer = Buffer.from(tag, "ascii");
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32BE(content.length, 0);
+  return Buffer.concat([tagBuffer, lengthBuffer, content]);
+}
+function encodePlaybackStatus(status) {
+  const tags = [];
+  if (status.playing !== undefined) {
+    tags.push(encodeTagWithSize("caps", status.playing ? 4 : 3, 1));
+  }
+  if (status.shuffle !== undefined) {
+    tags.push(encodeTagWithSize("cash", status.shuffle ? 1 : 0, 1));
+  }
+  if (status.repeat !== undefined) {
+    let repeatValue = 0;
+    if (status.repeat === "one")
+      repeatValue = 1;
+    else if (status.repeat === "all")
+      repeatValue = 2;
+    tags.push(encodeTagWithSize("carp", repeatValue, 1));
+  }
+  return Buffer.concat(tags);
+}
+function encodeTagWithSize(tag, value, byteSize) {
+  if (tag.length !== 4) {
+    throw new Error(`Invalid DAAP tag: ${tag}. Tags must be exactly 4 characters.`);
+  }
+  const tagBuffer = Buffer.from(tag, "ascii");
+  const valueBuffer = Buffer.alloc(byteSize);
+  switch (byteSize) {
+    case 1:
+      valueBuffer.writeUInt8(value, 0);
+      break;
+    case 2:
+      valueBuffer.writeUInt16BE(value, 0);
+      break;
+    case 4:
+      valueBuffer.writeUInt32BE(value, 0);
+      break;
+    case 8:
+      valueBuffer.writeBigUInt64BE(BigInt(value), 0);
+      break;
+  }
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32BE(byteSize, 0);
+  return Buffer.concat([tagBuffer, lengthBuffer, valueBuffer]);
+}
+function encodeTrackMetadata(metadata) {
+  const tags = [];
+  if (metadata.title !== undefined) {
+    tags.push(encodeTag("minm", metadata.title));
+  }
+  if (metadata.artist !== undefined) {
+    tags.push(encodeTag("asar", metadata.artist));
+  }
+  if (metadata.albumArtist !== undefined) {
+    tags.push(encodeTag("asaa", metadata.albumArtist));
+  }
+  if (metadata.album !== undefined) {
+    tags.push(encodeTag("asal", metadata.album));
+  }
+  if (metadata.composer !== undefined) {
+    tags.push(encodeTag("ascp", metadata.composer));
+  }
+  if (metadata.genre !== undefined) {
+    tags.push(encodeTag("asgn", metadata.genre));
+  }
+  if (metadata.duration !== undefined) {
+    tags.push(encodeTagWithSize("astm", Math.floor(metadata.duration * 1000), 4));
+  }
+  if (metadata.trackNumber !== undefined) {
+    tags.push(encodeTagWithSize("astn", metadata.trackNumber, 2));
+  }
+  if (metadata.trackCount !== undefined) {
+    tags.push(encodeTagWithSize("astc", metadata.trackCount, 2));
+  }
+  if (metadata.discNumber !== undefined) {
+    tags.push(encodeTagWithSize("asdn", metadata.discNumber, 2));
+  }
+  if (metadata.discCount !== undefined) {
+    tags.push(encodeTagWithSize("asdc", metadata.discCount, 2));
+  }
+  if (metadata.year !== undefined) {
+    tags.push(encodeTagWithSize("asyr", metadata.year, 2));
+  }
+  if (metadata.bitrate !== undefined) {
+    tags.push(encodeTagWithSize("asbr", metadata.bitrate, 2));
+  }
+  if (metadata.sampleRate !== undefined) {
+    tags.push(encodeTagWithSize("assr", metadata.sampleRate, 4));
+  }
+  if (metadata.size !== undefined) {
+    tags.push(encodeTagWithSize("assz", metadata.size, 4));
+  }
+  const content = Buffer.concat(tags);
+  return encodeContainer("mlit", content);
+}
+function decode(buffer) {
+  const tags = [];
+  let remaining = buffer;
+  while (remaining.length > 0) {
+    const result = decodeTag(remaining);
+    if (!result)
+      break;
+    const [tag, rest] = result;
+    tags.push(tag);
+    remaining = rest;
+  }
+  return tags;
+}
+function decodeTag(buffer) {
+  if (buffer.length < 8) {
+    return null;
+  }
+  const tag = buffer.subarray(0, 4).toString("ascii");
+  const length = buffer.readUInt32BE(4);
+  if (buffer.length < 8 + length) {
+    return null;
+  }
+  const value = buffer.subarray(8, 8 + length);
+  const remaining = buffer.subarray(8 + length);
+  return [{ tag, length, value }, remaining];
+}
+function decodeToObject(buffer) {
+  const result = {};
+  const tags = decode(buffer);
+  for (const { tag, value } of tags) {
+    const tagType = TagType[tag];
+    if (tagType === undefined) {
+      result[tag] = value;
+    } else if (tagType === 12) {
+      result[tag] = decodeToObject(value);
+    } else if (tagType === 9) {
+      result[tag] = value.toString("utf8");
+    } else if (tagType === 1 || tagType === 2) {
+      result[tag] = value.readUInt8(0);
+    } else if (tagType === 3 || tagType === 4) {
+      result[tag] = value.readUInt16BE(0);
+    } else if (tagType === 5 || tagType === 6) {
+      result[tag] = value.readUInt32BE(0);
+    } else if (tagType === 7 || tagType === 8) {
+      result[tag] = value.readBigUInt64BE(0);
+    } else {
+      result[tag] = value;
+    }
+  }
+  return result;
+}
+function decodeTrackMetadata(buffer) {
+  const obj = decodeToObject(buffer);
+  const mlit = obj.mlit ?? obj;
+  return {
+    title: mlit.minm,
+    artist: mlit.asar,
+    albumArtist: mlit.asaa,
+    album: mlit.asal,
+    composer: mlit.ascp,
+    genre: mlit.asgn,
+    duration: mlit.astm !== undefined ? mlit.astm / 1000 : undefined,
+    trackNumber: mlit.astn,
+    trackCount: mlit.astc,
+    discNumber: mlit.asdn,
+    discCount: mlit.asdc,
+    year: mlit.asyr,
+    bitrate: mlit.asbr,
+    sampleRate: mlit.assr,
+    size: mlit.assz
+  };
+}
 // src/ntp.ts
 var exports_ntp = {};
 __export(exports_ntp, {
@@ -16,7 +294,7 @@ __export(exports_ntp, {
   ns: () => ns,
   now: () => now,
   encode: () => encode,
-  decode: () => decode
+  decode: () => decode2
 });
 var EPOCH = 0x83AA7E80n;
 function now() {
@@ -34,7 +312,7 @@ function parts(ntp) {
     Number(ntp & 0xFFFFFFFFn)
   ];
 }
-function decode(buffer) {
+function decode2(buffer) {
   if (buffer.length < 24) {
     throw new RangeError(`NTP packet too small: expected at least 24 bytes, got ${buffer.length}`);
   }
@@ -72,7 +350,7 @@ __export(exports_opack, {
   int: () => int,
   float: () => float,
   encode: () => encode2,
-  decode: () => decode2
+  decode: () => decode3
 });
 var TAG = {
   TRUE: 1,
@@ -160,7 +438,7 @@ function int(value) {
 function sizedInteger(value, size) {
   return new SizedInteger(value, size);
 }
-function decode2(data) {
+function decode3(data) {
   const [value] = _unpack(data, []);
   return value;
 }
@@ -1172,7 +1450,7 @@ function parseResponseHeaders(buffer) {
 var exports_tlv8 = {};
 __export(exports_tlv8, {
   encode: () => encode3,
-  decode: () => decode3,
+  decode: () => decode4,
   bail: () => bail,
   Value: () => Value,
   State: () => State,
@@ -1267,7 +1545,7 @@ function encode3(entries) {
   }
   return Buffer.from(chunks);
 }
-function decode3(buf) {
+function decode4(buf) {
   const map = new Map;
   let i = 0;
   while (i < buf.length) {
@@ -1289,5 +1567,6 @@ export {
   exports_rtsp as RTSP,
   exports_plist as Plist,
   exports_opack as OPack,
-  exports_ntp as NTP
+  exports_ntp as NTP,
+  exports_daap as DAAP
 };

package/dist/rtsp.d.ts

@@ -1,4 +1,4 @@
-export type Method = "GET" | "OPTIONS" | "POST" | "PUT" | "GET_PARAMETER" | "SET_PARAMETER" | "ANNOUNCE" | "RECORD" | "SETUP" | "TEARDOWN";
+export type Method = "GET" | "OPTIONS" | "POST" | "PUT" | "GET_PARAMETER" | "SET_PARAMETER" | "ANNOUNCE" | "FLUSH" | "RECORD" | "SETUP" | "TEARDOWN";
 export declare function makeHeader(method: Method, path: string, headers: HeadersInit, cseq: number, activeRemote: string, dacpId: string, sessionId: string): string;
 export declare function makeRequest(buffer: Buffer): HttpRequest | null;
 export declare function makeResponse(buffer: Buffer): HttpResponse | null;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-encoding",
     "description": "Common encoding utilities for Apple Protocols.",
-    "version": "0.5.4",
+    "version": "0.6.0",
     "type": "module",
     "license": "MIT",
     "author": {