@deafwave/osrs-botmaker-config-manager 0.2.6

package/dist/data/profile/keys.js

@@ -0,0 +1,41 @@
+import { getGroupKeys } from '../group/keys.js';
+import { RS_PROFILE_GROUP_SEGMENT, buildProfileGroupName, extractProfileKeyFromConfigKey } from '../shared/profile-group.js';
+export const getProfileKey = () => configManager.getRSProfileKey();
+export const getProfileGroupName = (groupName, profileKey) => buildProfileGroupName(groupName, profileKey);
+export const getProfileKeysForGroup = (groupName) => {
+    const prefix = `${groupName}${RS_PROFILE_GROUP_SEGMENT}`;
+    const keys = getGroupKeys(prefix);
+    const profileKeys = new Set();
+    keys.forEach((fullKey) => {
+        const profileKey = extractProfileKeyFromConfigKey(fullKey, prefix);
+        if (profileKey) {
+            profileKeys.add(profileKey);
+        }
+    });
+    return Array.from(profileKeys);
+};
+export const logProfileConfigSummary = (groupName) => {
+    const prefix = `${groupName}${RS_PROFILE_GROUP_SEGMENT}`;
+    const keys = getGroupKeys(prefix);
+    if (keys.length === 0) {
+        bot.printLogMessage(`No profile-scoped config keys found for group '${groupName}'.`);
+        return;
+    }
+    const counts = new Map();
+    keys.forEach((fullKey) => {
+        const profileKey = extractProfileKeyFromConfigKey(fullKey, prefix);
+        if (!profileKey) {
+            return;
+        }
+        counts.set(profileKey, (counts.get(profileKey) ?? 0) + 1);
+    });
+    const activeProfileKey = getProfileKey();
+    bot.printLogMessage(`Profile-scoped config summary for group '${groupName}': ${counts.size} profile(s), ${keys.length} key(s). Active profile: ${activeProfileKey}`);
+    Array.from(counts.entries())
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .forEach(([profileKey, count]) => {
+        const marker = profileKey === activeProfileKey ? ' (active)' : '';
+        bot.printLogMessage(`Profile ${profileKey}${marker}: ${count} key(s)`);
+    });
+};
+export const getProfileConfigKeys = (groupName, keyPrefix = '') => configManager.getRSProfileConfigurationKeys(groupName, getProfileKey(), keyPrefix);

package/dist/data/profile/number-arrays.d.ts

@@ -0,0 +1,2 @@
+export declare const getProfileNumberArray: (groupName: string, key: string, fallback?: number[] | undefined) => number[];
+export declare const setProfileNumberArray: (groupName: string, key: string, values: number[], options?: import("../shared/types.js").ConfigWriteOptions | undefined) => void;

package/dist/data/profile/number-arrays.js

@@ -0,0 +1,5 @@
+import { createNumberArrayAccessors } from '../shared/accessors.js';
+import { getProfileString, setProfileString } from './strings.js';
+const numberArrayAccessors = createNumberArrayAccessors(getProfileString, setProfileString);
+export const getProfileNumberArray = numberArrayAccessors.getNumberArray;
+export const setProfileNumberArray = numberArrayAccessors.setNumberArray;

package/dist/data/profile/numbers.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export declare const getProfileNumber: (groupName: string, key: string, fallback?: number | undefined) => number;
+export declare const getProfileInt: (groupName: string, key: string, fallback?: number | undefined) => number;
+export declare const getProfileFloat: (groupName: string, key: string, fallback?: number | undefined) => number;
+export declare const setProfileNumber: (groupName: string, key: string, value: number, options?: ConfigWriteOptions | undefined) => void;
+export declare const getProfileIntForProfileKey: (groupName: string, profileKey: string, key: string, fallback?: number) => number;
+export declare const setProfileNumberForProfileKey: (groupName: string, profileKey: string, key: string, value: number, options?: ConfigWriteOptions) => void;

package/dist/data/profile/numbers.js

@@ -0,0 +1,15 @@
+import { createNumberAccessors, parseStoredNumberWith } from '../shared/accessors.js';
+import { parseIntNumber } from '../shared/parse-number.js';
+import { toStoredJson } from '../shared/storage.js';
+import { getProfileString, getProfileStringForProfileKey, setProfileString, setProfileStringForProfileKey } from './strings.js';
+const numberAccessors = createNumberAccessors(getProfileString, setProfileString);
+export const getProfileNumber = numberAccessors.getNumber;
+export const getProfileInt = numberAccessors.getInt;
+export const getProfileFloat = numberAccessors.getFloat;
+export const setProfileNumber = numberAccessors.setNumber;
+export const getProfileIntForProfileKey = (groupName, profileKey, key, fallback = 0) => {
+    return parseStoredNumberWith(getProfileStringForProfileKey(groupName, profileKey, key, ''), fallback, parseIntNumber);
+};
+export const setProfileNumberForProfileKey = (groupName, profileKey, key, value, options) => {
+    setProfileStringForProfileKey(groupName, profileKey, key, toStoredJson(value), options);
+};

package/dist/data/profile/string-arrays.d.ts

@@ -0,0 +1,2 @@
+export declare const getProfileStringArray: (groupName: string, key: string, fallback?: string[] | undefined) => string[];
+export declare const setProfileStringArray: (groupName: string, key: string, values: string[], options?: import("../shared/types.js").ConfigWriteOptions | undefined) => void;

package/dist/data/profile/string-arrays.js

@@ -0,0 +1,5 @@
+import { createStringArrayAccessors } from '../shared/accessors.js';
+import { getProfileString, setProfileString } from './strings.js';
+const stringArrayAccessors = createStringArrayAccessors(getProfileString, setProfileString);
+export const getProfileStringArray = stringArrayAccessors.getStringArray;
+export const setProfileStringArray = stringArrayAccessors.setStringArray;

package/dist/data/profile/strings.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export declare const getProfileRawValue: (groupName: string, key: string) => string | null;
+export declare const getProfileString: (groupName: string, key: string, fallback?: string) => string;
+export declare const setProfileString: (groupName: string, key: string, value: string, options?: ConfigWriteOptions) => void;
+export declare const getProfileStringForProfileKey: (groupName: string, profileKey: string, key: string, fallback?: string) => string;
+export declare const setProfileStringForProfileKey: (groupName: string, profileKey: string, key: string, value: string, options?: ConfigWriteOptions) => void;

package/dist/data/profile/strings.js

@@ -0,0 +1,43 @@
+import { getGroupString, setGroupString } from '../group/strings.js';
+import { normalizeConfigValue } from '../shared/normalize-config-value.js';
+import { parseStoredData } from '../shared/storage.js';
+import { buildProfileGroupName } from '../shared/profile-group.js';
+import { setRSProfileConfigurationValue } from '../shared/set-rs-profile-configuration.js';
+import { writeConfig } from '../shared/write-config.js';
+import { getProfileKey } from './keys.js';
+export const getProfileRawValue = (groupName, key) => {
+    const rawValue = normalizeConfigValue(configManager.getRSProfileConfiguration(groupName, key));
+    if (rawValue === null || rawValue === undefined) {
+        return null;
+    }
+    return rawValue;
+};
+export const getProfileString = (groupName, key, fallback = '') => {
+    const rawValue = getProfileRawValue(groupName, key);
+    if (rawValue === null) {
+        return fallback;
+    }
+    const parsed = parseStoredData(rawValue);
+    if (parsed.ok && typeof parsed.value === 'string') {
+        return parsed.value;
+    }
+    return rawValue;
+};
+export const setProfileString = (groupName, key, value, options) => {
+    writeConfig(() => {
+        setRSProfileConfigurationValue(groupName, key, value);
+    }, options);
+};
+export const getProfileStringForProfileKey = (groupName, profileKey, key, fallback = '') => {
+    if (profileKey === getProfileKey()) {
+        return getProfileString(groupName, key, fallback);
+    }
+    return getGroupString(buildProfileGroupName(groupName, profileKey), key, fallback);
+};
+export const setProfileStringForProfileKey = (groupName, profileKey, key, value, options) => {
+    if (profileKey === getProfileKey()) {
+        setProfileString(groupName, key, value, options);
+        return;
+    }
+    setGroupString(buildProfileGroupName(groupName, profileKey), key, value, options);
+};

package/dist/data/shared/accessors.d.ts

@@ -0,0 +1,35 @@
+import type { ConfigWriteOptions } from './types.js';
+export type GetStringAccessor = (groupName: string, key: string, fallback?: string) => string;
+export type SetStringAccessor = (groupName: string, key: string, value: string, options?: ConfigWriteOptions) => void;
+export type GetRawAccessor = (groupName: string, key: string) => string | null;
+export type NumberAccessors = {
+    getNumber: (groupName: string, key: string, fallback?: number) => number;
+    getInt: (groupName: string, key: string, fallback?: number) => number;
+    getFloat: (groupName: string, key: string, fallback?: number) => number;
+    setNumber: (groupName: string, key: string, value: number, options?: ConfigWriteOptions) => void;
+};
+export type BooleanAccessors = {
+    getBoolean: (groupName: string, key: string, fallback?: boolean) => boolean;
+    setBoolean: (groupName: string, key: string, value: boolean, options?: ConfigWriteOptions) => void;
+};
+export type NumberArrayAccessors = {
+    getNumberArray: (groupName: string, key: string, fallback?: number[]) => number[];
+    setNumberArray: (groupName: string, key: string, values: number[], options?: ConfigWriteOptions) => void;
+};
+export type StringArrayAccessors = {
+    getStringArray: (groupName: string, key: string, fallback?: string[]) => string[];
+    setStringArray: (groupName: string, key: string, values: string[], options?: ConfigWriteOptions) => void;
+};
+export type JsonAccessors = {
+    getJson: <T>(groupName: string, key: string, fallback: T) => T;
+    setJson: <T>(groupName: string, key: string, value: T, options?: ConfigWriteOptions) => void;
+};
+export declare const parseStoredNumberWith: (rawValue: string, fallback: number, parser: (value: string) => number | null) => number;
+export declare const parseStoredBoolean: (rawValue: string, fallback: boolean) => boolean;
+export declare const parseStoredNumberArray: (rawValue: string, fallback: number[]) => number[];
+export declare const parseStoredJson: <T>(rawValue: string, fallback: T) => T;
+export declare const createNumberAccessors: (getString: GetStringAccessor, setString: SetStringAccessor) => NumberAccessors;
+export declare const createBooleanAccessors: (getString: GetStringAccessor, setString: SetStringAccessor) => BooleanAccessors;
+export declare const createNumberArrayAccessors: (getString: GetStringAccessor, setString: SetStringAccessor) => NumberArrayAccessors;
+export declare const createStringArrayAccessors: (getString: GetStringAccessor, setString: SetStringAccessor) => StringArrayAccessors;
+export declare const createJsonAccessors: (getRawValue: GetRawAccessor, setString: SetStringAccessor) => JsonAccessors;

package/dist/data/shared/accessors.js

@@ -0,0 +1,95 @@
+import { parseBoolean } from './parse-boolean.js';
+import { parseFloatNumber, parseIntNumber, parseNumber } from './parse-number.js';
+import { splitCsv } from './split-csv.js';
+import { isNumberArray, parseStoredData, toStoredJson } from './storage.js';
+import { parseStringArrayValue, serializeStringArrayValue } from './string-array.js';
+export const parseStoredNumberWith = (rawValue, fallback, parser) => {
+    const parsed = parseStoredData(rawValue);
+    if (parsed.ok && typeof parsed.value === 'number' && Number.isFinite(parsed.value)) {
+        const parsedNumber = parser(String(parsed.value));
+        return parsedNumber === null ? fallback : parsedNumber;
+    }
+    if (parsed.ok && typeof parsed.value === 'string') {
+        const parsedStringValue = parser(parsed.value);
+        if (parsedStringValue !== null) {
+            return parsedStringValue;
+        }
+    }
+    const parsedRawValue = parser(rawValue);
+    return parsedRawValue === null ? fallback : parsedRawValue;
+};
+export const parseStoredBoolean = (rawValue, fallback) => {
+    const parsed = parseStoredData(rawValue);
+    if (parsed.ok && typeof parsed.value === 'boolean') {
+        return parsed.value;
+    }
+    if (parsed.ok && typeof parsed.value === 'string') {
+        return parseBoolean(parsed.value, fallback);
+    }
+    return parseBoolean(rawValue, fallback);
+};
+export const parseStoredNumberArray = (rawValue, fallback) => {
+    if (!rawValue.trim()) {
+        return fallback;
+    }
+    const parsed = parseStoredData(rawValue);
+    if (parsed.ok && isNumberArray(parsed.value)) {
+        return parsed.value;
+    }
+    const numbers = splitCsv(rawValue)
+        .map(parseNumber)
+        .filter((number_) => number_ !== null);
+    return numbers.length > 0 ? numbers : fallback;
+};
+export const parseStoredJson = (rawValue, fallback) => {
+    if (!rawValue.trim()) {
+        return fallback;
+    }
+    const parsed = parseStoredData(rawValue);
+    return parsed.ok ? parsed.value : fallback;
+};
+export const createNumberAccessors = (getString, setString) => ({
+    getNumber: (groupName, key, fallback = 0) => parseStoredNumberWith(getString(groupName, key, ''), fallback, parseNumber),
+    getInt: (groupName, key, fallback = 0) => parseStoredNumberWith(getString(groupName, key, ''), fallback, parseIntNumber),
+    getFloat: (groupName, key, fallback = 0) => parseStoredNumberWith(getString(groupName, key, ''), fallback, parseFloatNumber),
+    setNumber: (groupName, key, value, options) => {
+        setString(groupName, key, toStoredJson(value), options);
+    },
+});
+export const createBooleanAccessors = (getString, setString) => ({
+    getBoolean: (groupName, key, fallback = false) => parseStoredBoolean(getString(groupName, key, ''), fallback),
+    setBoolean: (groupName, key, value, options) => {
+        setString(groupName, key, value ? 'true' : 'false', options);
+    },
+});
+export const createNumberArrayAccessors = (getString, setString) => ({
+    getNumberArray: (groupName, key, fallback = []) => parseStoredNumberArray(getString(groupName, key, ''), fallback),
+    setNumberArray: (groupName, key, values, options) => {
+        setString(groupName, key, toStoredJson(values), options);
+    },
+});
+export const createStringArrayAccessors = (getString, setString) => ({
+    getStringArray: (groupName, key, fallback = []) => {
+        const rawValue = getString(groupName, key, '');
+        if (!rawValue.trim()) {
+            return fallback;
+        }
+        const entries = parseStringArrayValue(rawValue);
+        return entries.length > 0 ? entries : fallback;
+    },
+    setStringArray: (groupName, key, values, options) => {
+        setString(groupName, key, serializeStringArrayValue(values), options);
+    },
+});
+export const createJsonAccessors = (getRawValue, setString) => ({
+    getJson: (groupName, key, fallback) => {
+        const rawValue = getRawValue(groupName, key);
+        if (rawValue === null) {
+            return fallback;
+        }
+        return parseStoredJson(rawValue, fallback);
+    },
+    setJson: (groupName, key, value, options) => {
+        setString(groupName, key, toStoredJson(value), options);
+    },
+});

package/dist/data/shared/normalize-config-value.d.ts

@@ -0,0 +1 @@
+export declare const normalizeConfigValue: (value: unknown) => string | null;

package/dist/data/shared/normalize-config-value.js

@@ -0,0 +1,6 @@
+export const normalizeConfigValue = (value) => {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return typeof value === 'string' ? value : String(value);
+};

package/dist/data/shared/parse-boolean.d.ts

@@ -0,0 +1 @@
+export declare const parseBoolean: (value: string, fallback: boolean) => boolean;

package/dist/data/shared/parse-boolean.js

@@ -0,0 +1,13 @@
+export const parseBoolean = (value, fallback) => {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return fallback;
+    }
+    if (['true', '1', 'yes', 'y', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['false', '0', 'no', 'n', 'off'].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+};

package/dist/data/shared/parse-number.d.ts

@@ -0,0 +1,3 @@
+export declare const parseNumber: (value: string) => number | null;
+export declare const parseFloatNumber: (value: string) => number | null;
+export declare const parseIntNumber: (value: string) => number | null;

package/dist/data/shared/parse-number.js

@@ -0,0 +1,20 @@
+const NUMERIC_PATTERN = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
+const INTEGER_PATTERN = /^[+-]?\d+$/;
+const parseFiniteNumber = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || !NUMERIC_PATTERN.test(trimmed)) {
+        return null;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+export const parseNumber = (value) => parseFiniteNumber(value);
+export const parseFloatNumber = (value) => parseFiniteNumber(value);
+export const parseIntNumber = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || !INTEGER_PATTERN.test(trimmed)) {
+        return null;
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isFinite(parsed) ? parsed : null;
+};

package/dist/data/shared/profile-group.d.ts

@@ -0,0 +1,3 @@
+export declare const RS_PROFILE_GROUP_SEGMENT = ".rsprofile.";
+export declare const buildProfileGroupName: (groupName: string, profileKey: string) => string;
+export declare const extractProfileKeyFromConfigKey: (fullKey: string, prefix: string) => string | null;

package/dist/data/shared/profile-group.js

@@ -0,0 +1,13 @@
+export const RS_PROFILE_GROUP_SEGMENT = '.rsprofile.';
+export const buildProfileGroupName = (groupName, profileKey) => `${groupName}${RS_PROFILE_GROUP_SEGMENT}${profileKey}`;
+export const extractProfileKeyFromConfigKey = (fullKey, prefix) => {
+    if (!fullKey.startsWith(prefix)) {
+        return null;
+    }
+    const remainder = fullKey.slice(prefix.length);
+    if (!remainder) {
+        return null;
+    }
+    const profileKey = remainder.split('.')[0]?.trim();
+    return profileKey || null;
+};

package/dist/data/shared/set-rs-profile-configuration.d.ts

@@ -0,0 +1,5 @@
+export type RSProfileConfigValue = object | string | boolean;
+/**
+ * Upstream typing only accepts `object`, but runtime supports scalar values as well.
+ */
+export declare const setRSProfileConfigurationValue: (groupName: string, key: string, value: RSProfileConfigValue) => void;

package/dist/data/shared/set-rs-profile-configuration.js

@@ -0,0 +1,7 @@
+/**
+ * Upstream typing only accepts `object`, but runtime supports scalar values as well.
+ */
+export const setRSProfileConfigurationValue = (groupName, key, value) => {
+    const typedConfigManager = configManager;
+    typedConfigManager.setRSProfileConfiguration(groupName, key, value);
+};

package/dist/data/shared/split-csv.d.ts

@@ -0,0 +1 @@
+export declare const splitCsv: (value: string) => string[];

package/dist/data/shared/split-csv.js

@@ -0,0 +1,4 @@
+export const splitCsv = (value) => value
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);

package/dist/data/shared/storage.d.ts

@@ -0,0 +1,10 @@
+export type ParseOutcome = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+};
+export declare const toStoredJson: (value: unknown) => string;
+export declare const parseStoredData: (rawValue: string) => ParseOutcome;
+export declare const isStringArray: (value: unknown) => value is string[];
+export declare const isNumberArray: (value: unknown) => value is number[];

package/dist/data/shared/storage.js

@@ -0,0 +1,58 @@
+const INVALID_VALUE_ERROR = 'Config value must be JSON-serializable.';
+const ESCAPED_COLON_REGEX = /\\:/g;
+const TRAILING_COMMA_REGEX = /,\s*([\]}])/g;
+const safeParseJson = (value) => {
+    try {
+        return {
+            ok: true,
+            value: JSON.parse(value),
+        };
+    }
+    catch {
+        return {
+            ok: false,
+        };
+    }
+};
+// eslint-disable-next-line unicorn/prefer-string-replace-all -- NEEDED DO NOT CHANGE
+const stripTrailingCommas = (value) => value.replace(TRAILING_COMMA_REGEX, '$1');
+// eslint-disable-next-line unicorn/prefer-string-replace-all -- NEEDED DO NOT CHANGE
+const unescapeColons = (value) => value.replace(ESCAPED_COLON_REGEX, ':');
+const buildCandidates = (rawValue) => {
+    const candidates = [rawValue, unescapeColons(rawValue), stripTrailingCommas(rawValue), stripTrailingCommas(unescapeColons(rawValue))];
+    return Array.from(new Set(candidates));
+};
+export const toStoredJson = (value) => {
+    if (value === undefined || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint') {
+        throw new TypeError(INVALID_VALUE_ERROR);
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined) {
+            throw new TypeError(INVALID_VALUE_ERROR);
+        }
+        return serialized;
+    }
+    catch {
+        throw new TypeError(INVALID_VALUE_ERROR);
+    }
+};
+export const parseStoredData = (rawValue) => {
+    const trimmedValue = rawValue.trim();
+    if (!trimmedValue) {
+        return {
+            ok: false,
+        };
+    }
+    for (const candidate of buildCandidates(trimmedValue)) {
+        const parsed = safeParseJson(candidate);
+        if (parsed.ok) {
+            return parsed;
+        }
+    }
+    return {
+        ok: false,
+    };
+};
+export const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+export const isNumberArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'number' && Number.isFinite(entry));

package/dist/data/shared/string-array-codec.d.ts

@@ -0,0 +1,2 @@
+export declare const parseStringArrayValue: (rawValue: string) => string[];
+export declare const serializeStringArrayValue: (values: string[]) => string;

package/dist/data/shared/string-array-codec.js

@@ -0,0 +1,19 @@
+import { splitCsv } from './split-csv.js';
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+export const parseStringArrayValue = (rawValue) => {
+    const trimmed = rawValue.trim();
+    if (!trimmed) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (isStringArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Fall back to legacy CSV storage.
+    }
+    return splitCsv(rawValue);
+};
+export const serializeStringArrayValue = (values) => JSON.stringify(values);

package/dist/data/shared/string-array.d.ts

@@ -0,0 +1,2 @@
+export declare const parseStringArrayValue: (rawValue: string) => string[];
+export declare const serializeStringArrayValue: (values: string[]) => string;

package/dist/data/shared/string-array.js

@@ -0,0 +1,14 @@
+import { splitCsv } from './split-csv.js';
+import { isStringArray, parseStoredData, toStoredJson } from './storage.js';
+export const parseStringArrayValue = (rawValue) => {
+    const trimmed = rawValue.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const parsed = parseStoredData(trimmed);
+    if (parsed.ok && isStringArray(parsed.value)) {
+        return parsed.value;
+    }
+    return splitCsv(rawValue);
+};
+export const serializeStringArrayValue = (values) => toStoredJson(values);

package/dist/data/shared/types.d.ts

@@ -0,0 +1,4 @@
+export type ConfigWriteOptions = {
+    /** When true, call configManager.sendConfig() after the write. */
+    sync?: boolean;
+};

package/dist/data/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/data/shared/write-config.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigWriteOptions } from './types.js';
+export declare const writeConfig: (writer: () => void, options?: ConfigWriteOptions) => void;

package/dist/data/shared/write-config.js

@@ -0,0 +1,6 @@
+export const writeConfig = (writer, options) => {
+    writer();
+    if (options?.sync) {
+        configManager.sendConfig();
+    }
+};

package/dist/data/storage.d.ts

@@ -0,0 +1,14 @@
+export type RsProfileStorage = {
+    group: string;
+    sync?: boolean;
+    /** optional profile key override to read/write a specific profile. */
+    profileKey?: string;
+    /** Use group-level (non-profile) config storage instead of profile-scoped. */
+    scope?: 'profile' | 'group';
+};
+export declare const getStoredString: (storage: RsProfileStorage | undefined, key: string, fallback: string) => string;
+export declare const setStoredString: (storage: RsProfileStorage | undefined, key: string, value: string) => void;
+export declare const getStoredInt: (storage: RsProfileStorage | undefined, key: string, fallback: number) => number;
+export declare const setStoredInt: (storage: RsProfileStorage | undefined, key: string, value: number) => void;
+export declare const getStoredBoolean: (storage: RsProfileStorage | undefined, key: string, fallback: boolean) => boolean;
+export declare const setStoredBoolean: (storage: RsProfileStorage | undefined, key: string, value: boolean) => void;

package/dist/data/storage.js

@@ -0,0 +1,62 @@
+import { createConfigScope } from './config-scope.js';
+const INVALID_STORAGE_GROUP_ERROR = "Invalid RsProfileStorage: 'group' must be a non-empty string when storage is provided.";
+const resolveStorage = (storage) => {
+    if (storage === undefined) {
+        return undefined;
+    }
+    if (typeof storage.group !== 'string' || storage.group.trim().length === 0) {
+        throw new TypeError(INVALID_STORAGE_GROUP_ERROR);
+    }
+    return storage;
+};
+const getScope = (storage) => createConfigScope({
+    group: storage.group,
+    scope: storage.scope,
+    profileKey: storage.profileKey,
+    syncDefault: storage.sync,
+});
+export const getStoredString = (storage, key, fallback) => {
+    const validStorage = resolveStorage(storage);
+    if (validStorage) {
+        return getScope(validStorage).getString(key, fallback);
+    }
+    return bot.bmCache.getString(key, fallback);
+};
+export const setStoredString = (storage, key, value) => {
+    const validStorage = resolveStorage(storage);
+    if (validStorage) {
+        getScope(validStorage).set(key, value);
+        return;
+    }
+    bot.bmCache.saveString(key, value);
+};
+export const getStoredInt = (storage, key, fallback) => {
+    const validStorage = resolveStorage(storage);
+    if (validStorage) {
+        return getScope(validStorage).getInt(key, fallback);
+    }
+    return bot.bmCache.getInt(key, fallback);
+};
+export const setStoredInt = (storage, key, value) => {
+    const validStorage = resolveStorage(storage);
+    if (validStorage) {
+        getScope(validStorage).set(key, value);
+        return;
+    }
+    bot.bmCache.saveInt(key, value);
+};
+export const getStoredBoolean = (storage, key, fallback) => {
+    const validStorage = resolveStorage(storage);
+    if (validStorage) {
+        return getScope(validStorage).getBoolean(key, fallback);
+    }
+    return bot.bmCache.getBoolean(key, fallback);
+};
+export const setStoredBoolean = (storage, key, value) => {
+    const validStorage = resolveStorage(storage);
+    if (validStorage) {
+        getScope(validStorage).set(key, value);
+        return;
+    }
+    bot.bmCache.saveBoolean(key, value);
+};

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+export declare const group: {
+    get: (groupName: string, key: string) => import("./data/group/aliases.js").ConfigAliasValue;
+    getBoolean: (groupName: string, key: string, fallback?: boolean | undefined) => boolean;
+    getFloat: (groupName: string, key: string, fallback?: number | undefined) => number;
+    getInt: (groupName: string, key: string, fallback?: number | undefined) => number;
+    getJson: <T>(groupName: string, key: string, fallback: T) => T;
+    getKeys: (prefix: string) => string[];
+    getNumber: (groupName: string, key: string, fallback?: number | undefined) => number;
+    getNumberArray: (groupName: string, key: string, fallback?: number[] | undefined) => number[];
+    getString: (groupName: string, key: string, fallback?: string) => string;
+    getStringArray: (groupName: string, key: string, fallback?: string[] | undefined) => string[];
+    logSummary: (groupName: string) => void;
+    set: (groupName: string, key: string, value: unknown, options?: import("./data/shared/types.js").ConfigWriteOptions | undefined) => void;
+    unset: (groupName: string, key: string, options?: import("./data/shared/types.js").ConfigWriteOptions | undefined) => void;
+};
+export declare const profile: {
+    get: (groupName: string, key: string) => import("./data/profile/config.js").ProfileConfigAliasValue;
+    getBoolean: (groupName: string, key: string, fallback?: boolean | undefined) => boolean;
+    getBooleanForProfileKey: (groupName: string, profileKey: string, key: string, fallback?: boolean) => boolean;
+    getConfigKeys: (groupName: string, keyPrefix?: string) => string[];
+    getFloat: (groupName: string, key: string, fallback?: number | undefined) => number;
+    getGroupName: (groupName: string, profileKey: string) => string;
+    getInt: (groupName: string, key: string, fallback?: number | undefined) => number;
+    getIntForProfileKey: (groupName: string, profileKey: string, key: string, fallback?: number) => number;
+    getJson: <T>(groupName: string, key: string, fallback: T) => T;
+    getKey: () => string;
+    getKeysForGroup: (groupName: string) => string[];
+    getNumber: (groupName: string, key: string, fallback?: number | undefined) => number;
+    getNumberArray: (groupName: string, key: string, fallback?: number[] | undefined) => number[];
+    getString: (groupName: string, key: string, fallback?: string) => string;
+    getStringArray: (groupName: string, key: string, fallback?: string[] | undefined) => string[];
+    getStringForProfileKey: (groupName: string, profileKey: string, key: string, fallback?: string) => string;
+    logSummary: (groupName: string) => void;
+    set: (groupName: string, key: string, value: unknown, options?: import("./data/shared/types.js").ConfigWriteOptions | undefined) => void;
+    unset: (groupName: string, key: string, options?: import("./data/shared/types.js").ConfigWriteOptions | undefined) => void;
+};
+export { sendConfig } from './data/group/keys.js';
+export { createConfigScope, logConfigValues } from './data/config-scope.js';
+export type { ConfigScope, ConfigScopeMode, ConfigScopeOptions, LogConfigValuesOptions } from './data/config-scope.js';
+export type { ConfigWriteOptions } from './data/shared/types.js';
+export { getStoredBoolean, getStoredInt, getStoredString, setStoredBoolean, setStoredInt, setStoredString } from './data/storage.js';
+export type { RsProfileStorage } from './data/storage.js';