@elite-dangerous-plugin-framework/journal 0.20260211.0 → 0.20260214.1

package/dist/index.js

@@ -1,29 +1,43 @@
-// src/index.ts
+//#region src/index.ts
+/**
+* Use this converter if you do not care about precision of numbers - primarily if you do not need to handle IDs (e.g. System Adresses).
+*
+* It will treat **any** number as a IEEE 754 64 bit Float. This way integers are precise up to 15 digits, which is not enough for IDs. In these cases,
+* use {@link parseWithBigInt} if large Integers matter.
+*/
 function parseWithLossyIntegers(event) {
-  return JSON.parse(event);
+	return JSON.parse(event);
 }
+/**
+* Converts a Journal Entry to a Journal Event with *all* Integers replaced with BigInts.
+* An Item is considered an integer if it consists of at least one numerical (0..9), which can be prefixed by a `-`.
+* Trailing `.` or `.0` cause the item to be treated as a regular IEEE 754 64 bit Float.
+*
+* Use this if you need to work with System Addresses. Working with BigInt's is a bit more annoying as you cannot directly use some std library functions.
+*/
 function parseWithBigInt(event) {
-  return JSON.parse(event, (k, v, { source }) => {
-    const isInteger = /^-?\d+$/.test(source ?? "");
-    return isInteger ? BigInt(source) : v;
-  });
+	return JSON.parse(event, ((k, v, { source }) => {
+		return /^-?\d+$/.test(source ?? "") ? BigInt(source) : v;
+	}));
 }
+/**
+* Stringifies a JSON that may contain BigInt's. Any BigInt is serialized as a number without compromising on accuracy.
+*
+* This is done by stringifying the BigInt with a randomly generated marker, followed by replacing said marker, including the quotes escaping the string.
+* This function can be seen as the inverse to {@link parseWithBigInt}.
+*
+* @param input a JSON-safe object containing BigInt's.
+*/
 function stringifyBigIntJSON(input) {
-  const randomString = crypto.randomUUID();
-  const bigIntPrefix = randomString + "_";
-  const bigIntSuffix = "_" + randomString;
-  const jsonWithMarkers = JSON.stringify(input, (_, val) => {
-    if (typeof val !== "bigint") {
-      return val;
-    }
-    return bigIntPrefix + val.toString() + bigIntSuffix;
-  });
-  return jsonWithMarkers.replaceAll(`"${bigIntPrefix}`, "").replaceAll(`${bigIntSuffix}"`, "");
+	const randomString = crypto.randomUUID();
+	const bigIntPrefix = randomString + "_";
+	const bigIntSuffix = "_" + randomString;
+	return JSON.stringify(input, (_, val) => {
+		if (typeof val !== "bigint") return val;
+		return bigIntPrefix + val.toString() + bigIntSuffix;
+	}).replaceAll(`"${bigIntPrefix}`, "").replaceAll(`${bigIntSuffix}"`, "");
 }
-export {
-  stringifyBigIntJSON,
-  parseWithLossyIntegers,
-  parseWithBigInt
-};
 
-//# debugId=7058B078BE924F3E64756E2164756E21
+//#endregion
+export { parseWithBigInt, parseWithLossyIntegers, stringifyBigIntJSON };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,10 +1 @@
-{
-  "version": 3,
-  "sources": ["../src/index.ts"],
-  "sourcesContent": [
-    "import type { JournalEvent, JournalEvent_BI } from \"./generated/index.js\";\n\n/**\n * Use this converter if you do not care about precision of numbers - primarily if you do not need to handle IDs (e.g. System Adresses).\n *\n * It will treat **any** number as a IEEE 754 64 bit Float. This way integers are precise up to 15 digits, which is not enough for IDs. In these cases,\n * use {@link parseWithBigInt} if large Integers matter.\n */\nexport function parseWithLossyIntegers(event: string): JournalEvent {\n  return JSON.parse(event);\n}\n\n/**\n * Converts a Journal Entry to a Journal Event with *all* Integers replaced with BigInts.\n * An Item is considered an integer if it consists of at least one numerical (0..9), which can be prefixed by a `-`.\n * Trailing `.` or `.0` cause the item to be treated as a regular IEEE 754 64 bit Float.\n *\n * Use this if you need to work with System Addresses. Working with BigInt's is a bit more annoying as you cannot directly use some std library functions.\n */\nexport function parseWithBigInt(event: string): JournalEvent_BI {\n  return JSON.parse(event, ((k: any, v: any, { source }: any) => {\n    const isInteger = /^-?\\d+$/.test(source ?? \"\");\n    return isInteger ? BigInt(source) : v;\n  }) as any);\n}\n\n/**\n * Stringifies a JSON that may contain BigInt's. Any BigInt is serialized as a number without compromising on accuracy.\n *\n * This is done by stringifying the BigInt with a randomly generated marker, followed by replacing said marker, including the quotes escaping the string.\n * This function can be seen as the inverse to {@link parseWithBigInt}.\n *\n * @param input a JSON-safe object containing BigInt's.\n */\nexport function stringifyBigIntJSON(input: any): string {\n  const randomString = crypto.randomUUID();\n\n  const bigIntPrefix = randomString + \"_\";\n  const bigIntSuffix = \"_\" + randomString;\n  const jsonWithMarkers = JSON.stringify(input, (_, val) => {\n    if (typeof val !== \"bigint\") {\n      return val;\n    }\n    return bigIntPrefix + val.toString() + bigIntSuffix;\n  });\n\n  // this turns\n  // {\n  //   \"systemAddress\": \"someUUID_12345_someUUID\"\n  // }\n  // into\n  // {\n  //   \"systemAddress\": 12345\n  // }\n  // such that the consumer can handle it as a number or do some special stuff to handle as BigInt also\n\n  // we dont use a stable marker such as _BIGINT because this could lead to a payload being broken if said string actually appears (e.g. Ship Name).\n  // random UUIDv4s are considered impropable to collide\n  return jsonWithMarkers\n    .replaceAll(`\"${bigIntPrefix}`, \"\")\n    .replaceAll(`${bigIntSuffix}\"`, \"\");\n}\n\nexport { type JournalEvent, type JournalEvent_BI };\n"
-  ],
-  "mappings": ";AAQO,SAAS,sBAAsB,CAAC,OAA6B;AAAA,EAClE,OAAO,KAAK,MAAM,KAAK;AAAA;AAUlB,SAAS,eAAe,CAAC,OAAgC;AAAA,EAC9D,OAAO,KAAK,MAAM,OAAQ,CAAC,GAAQ,KAAU,aAAkB;AAAA,IAC7D,MAAM,YAAY,UAAU,KAAK,UAAU,EAAE;AAAA,IAC7C,OAAO,YAAY,OAAO,MAAM,IAAI;AAAA,GAC7B;AAAA;AAWJ,SAAS,mBAAmB,CAAC,OAAoB;AAAA,EACtD,MAAM,eAAe,OAAO,WAAW;AAAA,EAEvC,MAAM,eAAe,eAAe;AAAA,EACpC,MAAM,eAAe,MAAM;AAAA,EAC3B,MAAM,kBAAkB,KAAK,UAAU,OAAO,CAAC,GAAG,QAAQ;AAAA,IACxD,IAAI,OAAO,QAAQ,UAAU;AAAA,MAC3B,OAAO;AAAA,IACT;AAAA,IACA,OAAO,eAAe,IAAI,SAAS,IAAI;AAAA,GACxC;AAAA,EAcD,OAAO,gBACJ,WAAW,IAAI,gBAAgB,EAAE,EACjC,WAAW,GAAG,iBAAiB,EAAE;AAAA;",
-  "debugId": "7058B078BE924F3E64756E2164756E21",
-  "names": []
-}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { JournalEvent, JournalEvent_BI } from \"./generated/index.js\";\nexport * from \"./generated/events.js\";\nexport * from \"./generated/events.bi.js\";\n\n/**\n * Use this converter if you do not care about precision of numbers - primarily if you do not need to handle IDs (e.g. System Adresses).\n *\n * It will treat **any** number as a IEEE 754 64 bit Float. This way integers are precise up to 15 digits, which is not enough for IDs. In these cases,\n * use {@link parseWithBigInt} if large Integers matter.\n */\nexport function parseWithLossyIntegers(event: string): JournalEvent {\n  return JSON.parse(event);\n}\n\n/**\n * Converts a Journal Entry to a Journal Event with *all* Integers replaced with BigInts.\n * An Item is considered an integer if it consists of at least one numerical (0..9), which can be prefixed by a `-`.\n * Trailing `.` or `.0` cause the item to be treated as a regular IEEE 754 64 bit Float.\n *\n * Use this if you need to work with System Addresses. Working with BigInt's is a bit more annoying as you cannot directly use some std library functions.\n */\nexport function parseWithBigInt(event: string): JournalEvent_BI {\n  return JSON.parse(event, ((k: any, v: any, { source }: any) => {\n    const isInteger = /^-?\\d+$/.test(source ?? \"\");\n    return isInteger ? BigInt(source) : v;\n  }) as any);\n}\n\n/**\n * Stringifies a JSON that may contain BigInt's. Any BigInt is serialized as a number without compromising on accuracy.\n *\n * This is done by stringifying the BigInt with a randomly generated marker, followed by replacing said marker, including the quotes escaping the string.\n * This function can be seen as the inverse to {@link parseWithBigInt}.\n *\n * @param input a JSON-safe object containing BigInt's.\n */\nexport function stringifyBigIntJSON(input: any): string {\n  const randomString = crypto.randomUUID();\n\n  const bigIntPrefix = randomString + \"_\";\n  const bigIntSuffix = \"_\" + randomString;\n  const jsonWithMarkers = JSON.stringify(input, (_, val) => {\n    if (typeof val !== \"bigint\") {\n      return val;\n    }\n    return bigIntPrefix + val.toString() + bigIntSuffix;\n  });\n\n  // this turns\n  // {\n  //   \"systemAddress\": \"someUUID_12345_someUUID\"\n  // }\n  // into\n  // {\n  //   \"systemAddress\": 12345\n  // }\n  // such that the consumer can handle it as a number or do some special stuff to handle as BigInt also\n\n  // we dont use a stable marker such as _BIGINT because this could lead to a payload being broken if said string actually appears (e.g. Ship Name).\n  // random UUIDv4s are considered impropable to collide\n  return jsonWithMarkers\n    .replaceAll(`\"${bigIntPrefix}`, \"\")\n    .replaceAll(`${bigIntSuffix}\"`, \"\");\n}\n\nexport { type JournalEvent, type JournalEvent_BI };\n"],"mappings":";;;;;;;AAUA,SAAgB,uBAAuB,OAA6B;AAClE,QAAO,KAAK,MAAM,MAAM;;;;;;;;;AAU1B,SAAgB,gBAAgB,OAAgC;AAC9D,QAAO,KAAK,MAAM,SAAS,GAAQ,GAAQ,EAAE,aAAkB;AAE7D,SADkB,UAAU,KAAK,UAAU,GAAG,GAC3B,OAAO,OAAO,GAAG;IAC5B;;;;;;;;;;AAWZ,SAAgB,oBAAoB,OAAoB;CACtD,MAAM,eAAe,OAAO,YAAY;CAExC,MAAM,eAAe,eAAe;CACpC,MAAM,eAAe,MAAM;AAoB3B,QAnBwB,KAAK,UAAU,QAAQ,GAAG,QAAQ;AACxD,MAAI,OAAO,QAAQ,SACjB,QAAO;AAET,SAAO,eAAe,IAAI,UAAU,GAAG;GACvC,CAeC,WAAW,IAAI,gBAAgB,GAAG,CAClC,WAAW,GAAG,aAAa,IAAI,GAAG"}