@lightsparkdev/core 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @lightsparkdev/core
 
+## 1.2.2
+
+### Patch Changes
+
+- 07900ac: - Upgrade deps
+  - Upgrade TypeScript to 5.6.2 and some related type fixes
+  - Improve clean scripts
+
+## 1.2.1
+
+### Patch Changes
+
+- b43609d: - Add isObject
+
 ## 1.2.0
 
 ### Minor Changes

package/dist/{chunk-XRYQNSG7.js → chunk-22DUJXVY.js}

@@ -1,3 +1,8 @@
+// src/utils/arrays.ts
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
 // src/utils/base64.ts
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 var Base64 = {
@@ -737,7 +742,7 @@ function localeToCurrencySymbol(locale) {
 // src/utils/errors.ts
 var isError = (e) => {
   return Boolean(
-    typeof e === "object" && e !== null && "name" in e && typeof e.name === "string" && "message" in e && typeof e.message === "string" && "stack" in e && (!e.stack || typeof e.stack === "string")
+    typeof e === "object" && e !== null && "name" in e && typeof e.name === "string" && "message" in e && typeof e.message === "string"
   );
 };
 var isErrorWithMessage = (e) => {
@@ -921,8 +926,12 @@ function lsidToUUID(lsid) {
 }
 
 // src/utils/typeGuards.ts
-function isUint8Array(variable) {
-  return variable instanceof Uint8Array;
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isObject2(value) {
+  const type = typeof value;
+  return value != null && (type == "object" || type == "function");
 }
 
 // src/utils/types.ts
@@ -935,12 +944,13 @@ function notNullUndefined(value) {
 
 export {
   LightsparkException_default,
-  isBrowser,
-  isNode,
-  isTest,
   b64decode,
   urlsafe_b64decode,
   b64encode,
+  ensureArray,
+  isBrowser,
+  isNode,
+  isTest,
   bytesToHex,
   hexToBytes,
   createSha256Hash,
@@ -976,6 +986,7 @@ export {
   pollUntil,
   lsidToUUID,
   isUint8Array,
+  isObject2 as isObject,
   isType,
   notNullUndefined
 };

package/dist/{index-4698c2db.d.ts → index-DdZ7x9Ef.d.cts}

@@ -4,6 +4,8 @@ declare const ConfigKeys: {
 };
 type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
 
+declare function ensureArray<T>(value: T | T[]): T[];
+
 declare const b64decode: (encoded: string) => Uint8Array;
 declare const urlsafe_b64decode: (encoded: string) => Uint8Array;
 declare const b64encode: (data: ArrayBuffer) => string;
@@ -108,7 +110,7 @@ type ById<T> = {
 type OmitTypename<T> = Omit<T, "__typename">;
 declare const isType: <T extends string>(typename: T) => <N extends {
     __typename: string;
-}>(node: N | null | undefined) => node is Extract<N, {
+}>(node: N | undefined | null) => node is Extract<N, {
     __typename: T;
 }>;
 type DeepPartial<T> = T extends object ? {
@@ -140,11 +142,6 @@ declare function errorToJSON(err: unknown): JSONType;
 declare const bytesToHex: (bytes: Uint8Array) => string;
 declare const hexToBytes: (hex: string) => Uint8Array;
 
-declare function getLocalStorageConfigItem(key: ConfigKeys): boolean;
-declare function getLocalStorageBoolean(key: string): boolean;
-declare function setLocalStorageBoolean(key: string, value: boolean): void;
-declare const deleteLocalStorageItem: (key: string) => void;
-
 declare function getCurrentLocale(): string;
 
 declare const countryCodesToCurrencyCodes: {
@@ -218,6 +215,11 @@ type CurrencyLocales = keyof typeof countryCodesToCurrencyCodes;
 type CurrencyCodes = (typeof countryCodesToCurrencyCodes)[CurrencyLocales];
 declare function localeToCurrencyCode(locale: string): CurrencyCodes;
 
+declare function getLocalStorageConfigItem(key: ConfigKeys): boolean;
+declare function getLocalStorageBoolean(key: string): boolean;
+declare function setLocalStorageBoolean(key: string, value: boolean): void;
+declare const deleteLocalStorageItem: (key: string) => void;
+
 declare function clamp(val: number, min: number, max: number): number;
 declare function linearInterpolate(value: number, fromRangeStart: number, fromRangeEnd: number, toRangeStart: number, toRangeEnd: number): number;
 declare function round(num: number, decimalPlaces?: number): number;
@@ -236,6 +238,7 @@ declare function sleep(ms: number): Promise<unknown>;
 
 declare function lsidToUUID(lsid: string): string;
 
-declare function isUint8Array(variable: unknown): variable is Uint8Array;
+declare function isUint8Array(value: unknown): value is Uint8Array;
+declare function isObject(value: unknown): value is Record<string, unknown>;
 
-export { isType as $, isErrorMsg as A, errorToJSON as B, ConfigKeys as C, bytesToHex as D, hexToBytes as E, getLocalStorageConfigItem as F, getLocalStorageBoolean as G, setLocalStorageBoolean as H, deleteLocalStorageItem as I, getCurrentLocale as J, countryCodesToCurrencyCodes as K, CurrencyLocales as L, CurrencyCodes as M, localeToCurrencyCode as N, clamp as O, linearInterpolate as P, round as Q, isNumber as R, SDKCurrencyAmountType as S, pollUntil as T, sleep as U, lsidToUUID as V, isUint8Array as W, Maybe as X, ExpandRecursively as Y, ById as Z, OmitTypename as _, b64encode as a, DeepPartial as a0, JSONLiteral as a1, JSONType as a2, JSONObject as a3, NN as a4, notNullUndefined as a5, PartialBy as a6, Complete as a7, b64decode as b, createSha256Hash as c, defaultCurrencyCode as d, CurrencyUnit as e, CurrencyUnitType as f, convertCurrencyAmountValue as g, convertCurrencyAmount as h, CurrencyMap as i, CurrencyAmountObj as j, CurrencyAmountArg as k, isCurrencyAmountObj as l, isSDKCurrencyAmount as m, mapCurrencyAmount as n, isCurrencyMap as o, abbrCurrencyUnit as p, formatCurrencyStr as q, localeToCurrencySymbol as r, separateCurrencyStrParts as s, isBrowser as t, urlsafe_b64decode as u, isNode as v, isTest as w, isError as x, isErrorWithMessage as y, getErrorMsg as z };
+export { type ById as $, getErrorMsg as A, isErrorMsg as B, ConfigKeys as C, errorToJSON as D, bytesToHex as E, hexToBytes as F, getCurrentLocale as G, countryCodesToCurrencyCodes as H, type CurrencyLocales as I, type CurrencyCodes as J, localeToCurrencyCode as K, getLocalStorageConfigItem as L, getLocalStorageBoolean as M, setLocalStorageBoolean as N, deleteLocalStorageItem as O, clamp as P, linearInterpolate as Q, round as R, type SDKCurrencyAmountType as S, isNumber as T, pollUntil as U, sleep as V, lsidToUUID as W, isUint8Array as X, isObject as Y, type Maybe as Z, type ExpandRecursively as _, b64encode as a, type OmitTypename as a0, isType as a1, type DeepPartial as a2, type JSONLiteral as a3, type JSONType as a4, type JSONObject as a5, type NN as a6, notNullUndefined as a7, type PartialBy as a8, type Complete as a9, b64decode as b, createSha256Hash as c, defaultCurrencyCode as d, ensureArray as e, CurrencyUnit as f, type CurrencyUnitType as g, convertCurrencyAmountValue as h, convertCurrencyAmount as i, type CurrencyMap as j, type CurrencyAmountObj as k, type CurrencyAmountArg as l, isCurrencyAmountObj as m, isSDKCurrencyAmount as n, mapCurrencyAmount as o, isCurrencyMap as p, abbrCurrencyUnit as q, formatCurrencyStr as r, separateCurrencyStrParts as s, localeToCurrencySymbol as t, urlsafe_b64decode as u, isBrowser as v, isNode as w, isTest as x, isError as y, isErrorWithMessage as z };

package/dist/index-DdZ7x9Ef.d.ts

@@ -0,0 +1,244 @@
+declare const ConfigKeys: {
+    readonly LoggingEnabled: "lightspark-logging-enabled";
+    readonly ConsoleToolsEnabled: "lightspark-console-tools-enabled";
+};
+type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
+
+declare function ensureArray<T>(value: T | T[]): T[];
+
+declare const b64decode: (encoded: string) => Uint8Array;
+declare const urlsafe_b64decode: (encoded: string) => Uint8Array;
+declare const b64encode: (data: ArrayBuffer) => string;
+
+type SourceData = Uint8Array | string;
+declare function createSha256Hash(data: SourceData): Promise<Uint8Array>;
+declare function createSha256Hash(data: SourceData, asHex: true): Promise<string>;
+
+declare const defaultCurrencyCode = "USD";
+declare const CurrencyUnit: {
+    readonly FUTURE_VALUE: "FUTURE_VALUE";
+    readonly BITCOIN: "BITCOIN";
+    readonly SATOSHI: "SATOSHI";
+    readonly MILLISATOSHI: "MILLISATOSHI";
+    readonly USD: "USD";
+    readonly NANOBITCOIN: "NANOBITCOIN";
+    readonly MICROBITCOIN: "MICROBITCOIN";
+    readonly MILLIBITCOIN: "MILLIBITCOIN";
+    readonly Bitcoin: "BITCOIN";
+    readonly Microbitcoin: "MICROBITCOIN";
+    readonly Millibitcoin: "MILLIBITCOIN";
+    readonly Millisatoshi: "MILLISATOSHI";
+    readonly Nanobitcoin: "NANOBITCOIN";
+    readonly Satoshi: "SATOSHI";
+    readonly Usd: "USD";
+};
+type CurrencyUnitType = (typeof CurrencyUnit)[keyof typeof CurrencyUnit];
+type SDKCurrencyAmountType = {
+    originalValue: number;
+    originalUnit: CurrencyUnitType;
+    preferredCurrencyUnit: CurrencyUnitType;
+    preferredCurrencyValueRounded: number;
+    preferredCurrencyValueApprox: number;
+};
+declare function convertCurrencyAmountValue(fromUnit: CurrencyUnitType, toUnit: CurrencyUnitType, amount: number, centsPerBtc?: number): number;
+declare const convertCurrencyAmount: (from: SDKCurrencyAmountType, toUnit: CurrencyUnitType) => SDKCurrencyAmountType;
+type CurrencyMap = {
+    sats: number;
+    msats: number;
+    btc: number;
+    [CurrencyUnit.BITCOIN]: number;
+    [CurrencyUnit.SATOSHI]: number;
+    [CurrencyUnit.MILLISATOSHI]: number;
+    [CurrencyUnit.MICROBITCOIN]: number;
+    [CurrencyUnit.MILLIBITCOIN]: number;
+    [CurrencyUnit.NANOBITCOIN]: number;
+    [CurrencyUnit.USD]: number;
+    [CurrencyUnit.FUTURE_VALUE]: number;
+    formatted: {
+        sats: string;
+        msats: string;
+        btc: string;
+        [CurrencyUnit.BITCOIN]: string;
+        [CurrencyUnit.SATOSHI]: string;
+        [CurrencyUnit.MILLISATOSHI]: string;
+        [CurrencyUnit.MILLIBITCOIN]: string;
+        [CurrencyUnit.MICROBITCOIN]: string;
+        [CurrencyUnit.NANOBITCOIN]: string;
+        [CurrencyUnit.USD]: string;
+        [CurrencyUnit.FUTURE_VALUE]: string;
+    };
+    isZero: boolean;
+    isLessThan: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    isGreaterThan: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    isEqualTo: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    type: "CurrencyMap";
+};
+type CurrencyAmountObj = {
+    value?: number | string | null;
+    unit?: CurrencyUnitType;
+    __typename?: "CurrencyAmount" | undefined;
+};
+type CurrencyAmountArg = CurrencyAmountObj | SDKCurrencyAmountType | undefined | null;
+declare function isCurrencyAmountObj(arg: unknown): arg is CurrencyAmountObj;
+declare function isSDKCurrencyAmount(arg: unknown): arg is SDKCurrencyAmountType;
+declare function mapCurrencyAmount(currencyAmountArg: CurrencyAmountArg, centsPerBtc?: number): CurrencyMap;
+declare const isCurrencyMap: (currencyMap: unknown) => currencyMap is CurrencyMap;
+declare const abbrCurrencyUnit: (unit: CurrencyUnitType) => "USD" | "BTC" | "SAT" | "MSAT" | "Unsupported CurrencyUnit";
+type FormatCurrencyStrOptions = {
+    precision?: number | "full" | undefined;
+    compact?: boolean | undefined;
+    showBtcSymbol?: boolean | undefined;
+};
+declare function formatCurrencyStr(amount: CurrencyAmountArg, options?: FormatCurrencyStrOptions): string;
+declare function separateCurrencyStrParts(currencyStr: string): {
+    symbol: string;
+    amount: string;
+};
+declare function localeToCurrencySymbol(locale: string): string;
+
+declare const isBrowser: boolean;
+declare const isNode: boolean;
+declare const isTest: boolean;
+
+type Maybe<T> = T | null | undefined;
+type ExpandRecursively<T> = T extends object ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+type ById<T> = {
+    [id: string]: T;
+};
+type OmitTypename<T> = Omit<T, "__typename">;
+declare const isType: <T extends string>(typename: T) => <N extends {
+    __typename: string;
+}>(node: N | undefined | null) => node is Extract<N, {
+    __typename: T;
+}>;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type JSONLiteral = string | number | boolean | null;
+type JSONType = JSONLiteral | JSONType[] | {
+    [key: string]: JSONType;
+};
+type JSONObject = {
+    [key: string]: JSONType;
+};
+type NN<T> = NonNullable<T>;
+declare function notNullUndefined<TValue>(value: TValue | null | undefined): value is TValue;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type Complete<T> = {
+    [P in keyof T]-?: NonNullable<T[P]>;
+};
+
+declare const isError: (e: unknown) => e is Error;
+type ErrorWithMessage = {
+    message: string;
+};
+declare const isErrorWithMessage: (e: unknown) => e is ErrorWithMessage;
+declare const getErrorMsg: (e: unknown) => string;
+declare const isErrorMsg: (e: unknown, msg: string) => boolean;
+declare function errorToJSON(err: unknown): JSONType;
+
+declare const bytesToHex: (bytes: Uint8Array) => string;
+declare const hexToBytes: (hex: string) => Uint8Array;
+
+declare function getCurrentLocale(): string;
+
+declare const countryCodesToCurrencyCodes: {
+    readonly AD: "EUR";
+    readonly AR: "ARS";
+    readonly AS: "USD";
+    readonly AT: "EUR";
+    readonly AU: "AUD";
+    readonly AX: "EUR";
+    readonly BE: "EUR";
+    readonly BL: "EUR";
+    readonly BQ: "USD";
+    readonly BR: "BRL";
+    readonly CA: "CAD";
+    readonly CO: "COP";
+    readonly CY: "EUR";
+    readonly DE: "EUR";
+    readonly EC: "USD";
+    readonly EE: "EUR";
+    readonly ES: "EUR";
+    readonly FI: "EUR";
+    readonly FM: "USD";
+    readonly FR: "EUR";
+    readonly GB: "GBP";
+    readonly GF: "EUR";
+    readonly GG: "GBP";
+    readonly GP: "EUR";
+    readonly GR: "EUR";
+    readonly GS: "GBP";
+    readonly GU: "USD";
+    readonly IE: "EUR";
+    readonly IM: "GBP";
+    readonly IN: "INR";
+    readonly IO: "USD";
+    readonly IT: "EUR";
+    readonly JE: "GBP";
+    readonly LT: "EUR";
+    readonly LU: "EUR";
+    readonly LV: "EUR";
+    readonly MC: "EUR";
+    readonly ME: "EUR";
+    readonly MF: "EUR";
+    readonly MH: "USD";
+    readonly MP: "USD";
+    readonly MQ: "EUR";
+    readonly MT: "EUR";
+    readonly MX: "MXN";
+    readonly NF: "AUD";
+    readonly NL: "EUR";
+    readonly NR: "AUD";
+    readonly PM: "EUR";
+    readonly PR: "USD";
+    readonly PT: "EUR";
+    readonly PW: "USD";
+    readonly RE: "EUR";
+    readonly SI: "EUR";
+    readonly SK: "EUR";
+    readonly SM: "EUR";
+    readonly TC: "USD";
+    readonly TF: "EUR";
+    readonly TL: "USD";
+    readonly TV: "AUD";
+    readonly UM: "USD";
+    readonly US: "USD";
+    readonly VA: "EUR";
+    readonly VG: "USD";
+    readonly VI: "USD";
+    readonly YT: "EUR";
+};
+type CurrencyLocales = keyof typeof countryCodesToCurrencyCodes;
+type CurrencyCodes = (typeof countryCodesToCurrencyCodes)[CurrencyLocales];
+declare function localeToCurrencyCode(locale: string): CurrencyCodes;
+
+declare function getLocalStorageConfigItem(key: ConfigKeys): boolean;
+declare function getLocalStorageBoolean(key: string): boolean;
+declare function setLocalStorageBoolean(key: string, value: boolean): void;
+declare const deleteLocalStorageItem: (key: string) => void;
+
+declare function clamp(val: number, min: number, max: number): number;
+declare function linearInterpolate(value: number, fromRangeStart: number, fromRangeEnd: number, toRangeStart: number, toRangeEnd: number): number;
+declare function round(num: number, decimalPlaces?: number): number;
+declare function isNumber(value: unknown): value is number;
+
+type GetValueResult<T> = {
+    stopPolling: boolean;
+    value: null | T;
+};
+declare function pollUntil<D extends () => Promise<unknown>, T>(asyncFn: D, getValue: (data: Awaited<ReturnType<D>>, response: {
+    stopPolling: boolean;
+    value: null | T;
+}) => GetValueResult<T>, maxPolls?: number, pollIntervalMs?: number, ignoreErrors?: boolean | ((e: unknown) => boolean), getMaxPollsError?: (maxPolls: number) => Error): Promise<T>;
+
+declare function sleep(ms: number): Promise<unknown>;
+
+declare function lsidToUUID(lsid: string): string;
+
+declare function isUint8Array(value: unknown): value is Uint8Array;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+
+export { type ById as $, getErrorMsg as A, isErrorMsg as B, ConfigKeys as C, errorToJSON as D, bytesToHex as E, hexToBytes as F, getCurrentLocale as G, countryCodesToCurrencyCodes as H, type CurrencyLocales as I, type CurrencyCodes as J, localeToCurrencyCode as K, getLocalStorageConfigItem as L, getLocalStorageBoolean as M, setLocalStorageBoolean as N, deleteLocalStorageItem as O, clamp as P, linearInterpolate as Q, round as R, type SDKCurrencyAmountType as S, isNumber as T, pollUntil as U, sleep as V, lsidToUUID as W, isUint8Array as X, isObject as Y, type Maybe as Z, type ExpandRecursively as _, b64encode as a, type OmitTypename as a0, isType as a1, type DeepPartial as a2, type JSONLiteral as a3, type JSONType as a4, type JSONObject as a5, type NN as a6, notNullUndefined as a7, type PartialBy as a8, type Complete as a9, b64decode as b, createSha256Hash as c, defaultCurrencyCode as d, ensureArray as e, CurrencyUnit as f, type CurrencyUnitType as g, convertCurrencyAmountValue as h, convertCurrencyAmount as i, type CurrencyMap as j, type CurrencyAmountObj as k, type CurrencyAmountArg as l, isCurrencyAmountObj as m, isSDKCurrencyAmount as n, mapCurrencyAmount as o, isCurrencyMap as p, abbrCurrencyUnit as q, formatCurrencyStr as r, separateCurrencyStrParts as s, localeToCurrencySymbol as t, urlsafe_b64decode as u, isBrowser as v, isNode as w, isTest as x, isError as y, isErrorWithMessage as z };