@deafwave/osrs-botmaker-config-manager 0.2.6

package/README.md

@@ -0,0 +1,54 @@
+# @deafwave/osrs-botmaker-config-manager
+
+## Install
+
+```bash
+pnpm add @deafwave/osrs-botmaker-config-manager
+```
+
+## Usage
+
+```ts
+group.set('builder', 'mode', 'safe')
+const mode = group.getString('builder', 'mode', 'fallback')
+
+profile.set('builder', 'enabled', true)
+profile.set('builder', 'bankitems', [1171, 1])
+profile.set('builder', 'mode', 'safe')
+const enabled = profile.getBoolean('builder', 'enabled', false)
+
+const scope = createConfigScope({ group: 'builder.scope', scope: 'group' })
+scope.set('runs', 7)
+scope.set('drops', [526, 2])
+scope.set('meta', { mode: 'safe' })
+
+const storage: RsProfileStorage = { group: 'builder', sync: true }
+setStoredString(storage, 'mode', 'safe')
+const storedMode = getStoredString(storage, 'mode', 'fallback')
+```
+
+## Generic Setter Values
+
+`group.set`, `profile.set`, and `scope.set` accept any JSON-serializable value.
+
+Accepted values include:
+
+- strings
+- numbers
+- booleans
+- `null`
+- arrays
+- plain objects
+
+Rejected values throw `TypeError("Config value must be JSON-serializable.")`:
+
+- `undefined`
+- functions
+- symbols
+- bigint values
+- circular / non-serializable objects
+
+## Sync Behavior
+
+Writes do not call `configManager.sendConfig()` unless sync is enabled.
+- Manual sync: call `sendConfig()` to force sending config.

package/dist/data/config-scope.d.ts

@@ -0,0 +1,31 @@
+import type { ConfigWriteOptions } from './shared/types.js';
+export type ConfigScopeMode = 'group' | 'profile';
+export type ConfigScopeOptions = {
+    group: string;
+    scope?: ConfigScopeMode;
+    profileKey?: string;
+    syncDefault?: boolean;
+};
+export type LogConfigValuesOptions = {
+    action: string;
+    group: string;
+    getAllValues: (keyPrefix?: string) => Record<string, string>;
+    keyPrefix?: string;
+};
+export type ConfigScope = {
+    getKeys: (keyPrefix?: string) => string[];
+    getAllValues: (keyPrefix?: string) => Record<string, string>;
+    logAllValues: (action: string, keyPrefix?: string) => Record<string, string>;
+    getString: (key: string, fallback?: string) => string;
+    set: (key: string, value: unknown, options?: ConfigWriteOptions) => void;
+    getNumber: (key: string, fallback?: number) => number;
+    getInt: (key: string, fallback?: number) => number;
+    getFloat: (key: string, fallback?: number) => number;
+    getBoolean: (key: string, fallback?: boolean) => boolean;
+    getStringArray: (key: string, fallback?: string[]) => string[];
+    getNumberArray: (key: string, fallback?: number[]) => number[];
+    getJson: <T>(key: string, fallback: T) => T;
+    unset: (key: string, options?: ConfigWriteOptions) => void;
+};
+export declare const logConfigValues: ({ action, group, getAllValues, keyPrefix }: LogConfigValuesOptions) => Record<string, string>;
+export declare const createConfigScope: (options: ConfigScopeOptions) => ConfigScope;

package/dist/data/config-scope.js

@@ -0,0 +1,302 @@
+import { setGroupValue } from './group/aliases.js';
+import { getGroupBoolean } from './group/booleans.js';
+import { getGroupJson } from './group/json.js';
+import { getGroupKeys, unsetGroupValue } from './group/keys.js';
+import { getGroupNumberArray } from './group/number-arrays.js';
+import { getGroupFloat, getGroupInt, getGroupNumber } from './group/numbers.js';
+import { getGroupStringArray } from './group/string-arrays.js';
+import { getGroupString } from './group/strings.js';
+import { getProfileBoolean, getProfileBooleanForProfileKey } from './profile/booleans.js';
+import { setProfileValue, unsetProfileValue } from './profile/config.js';
+import { getProfileJson } from './profile/json.js';
+import { getProfileConfigKeys, getProfileKey } from './profile/keys.js';
+import { getProfileNumberArray } from './profile/number-arrays.js';
+import { getProfileFloat, getProfileInt, getProfileIntForProfileKey, getProfileNumber } from './profile/numbers.js';
+import { getProfileStringArray } from './profile/string-arrays.js';
+import { getProfileString, getProfileStringForProfileKey } from './profile/strings.js';
+import { parseFloatNumber, parseNumber } from './shared/parse-number.js';
+import { buildProfileGroupName } from './shared/profile-group.js';
+import { splitCsv } from './shared/split-csv.js';
+import { isNumberArray, parseStoredData } from './shared/storage.js';
+import { parseStringArrayValue } from './shared/string-array.js';
+const INVALID_SCOPE_GROUP_ERROR = "Invalid ConfigScopeOptions: 'group' must be a non-empty string.";
+const INVALID_SCOPE_PROFILE_KEY_ERROR = "Invalid ConfigScopeOptions: 'profileKey' must be a non-empty string when provided.";
+const PROFILE_KEY_WITH_GROUP_SCOPE_ERROR = "Invalid ConfigScopeOptions: 'profileKey' cannot be used when scope is 'group'.";
+const INVALID_SCOPE_MODE_ERROR = "Invalid ConfigScopeOptions: 'scope' must be either 'group' or 'profile'.";
+const INVALID_SYNC_DEFAULT_ERROR = "Invalid ConfigScopeOptions: 'syncDefault' must be a boolean when provided.";
+const ERROR = 'Invalid ConfigScopeOptions.';
+const logAndThrowTypeError = (message) => {
+    log.printColor(message, java.awt.Color.RED);
+    throw new TypeError(ERROR);
+};
+const parseConfigScopeMode = (value) => {
+    if (value === 'group' || value === 'profile') {
+        return value;
+    }
+    return logAndThrowTypeError(INVALID_SCOPE_MODE_ERROR);
+};
+const parseOptionalProfileKey = (profileKey) => {
+    if (profileKey === undefined) {
+        return undefined;
+    }
+    if (typeof profileKey !== 'string') {
+        return logAndThrowTypeError(INVALID_SCOPE_PROFILE_KEY_ERROR);
+    }
+    const trimmed = profileKey.trim();
+    if (!trimmed) {
+        return logAndThrowTypeError(INVALID_SCOPE_PROFILE_KEY_ERROR);
+    }
+    return trimmed;
+};
+const parseGroupName = (group) => {
+    if (typeof group !== 'string') {
+        return logAndThrowTypeError(INVALID_SCOPE_GROUP_ERROR);
+    }
+    const trimmed = group.trim();
+    if (!trimmed) {
+        return logAndThrowTypeError(INVALID_SCOPE_GROUP_ERROR);
+    }
+    return trimmed;
+};
+const parseSyncDefault = (syncDefault) => {
+    if (syncDefault === undefined) {
+        return undefined;
+    }
+    if (typeof syncDefault !== 'boolean') {
+        return logAndThrowTypeError(INVALID_SYNC_DEFAULT_ERROR);
+    }
+    return syncDefault;
+};
+const withSyncDefault = (syncDefault, options) => {
+    if (options?.sync !== undefined) {
+        return options;
+    }
+    if (syncDefault === undefined) {
+        return options;
+    }
+    return { ...options, sync: syncDefault };
+};
+const parseNumberArrayFromString = (value, fallback) => {
+    const parsed = parseStoredData(value);
+    if (parsed.ok && isNumberArray(parsed.value)) {
+        return parsed.value;
+    }
+    if (!value.trim()) {
+        return fallback;
+    }
+    const numbers = splitCsv(value)
+        .map(parseNumber)
+        .filter((number_) => number_ !== null);
+    return numbers.length > 0 ? numbers : fallback;
+};
+const parseJsonFromString = (value, fallback) => {
+    if (!value.trim()) {
+        return fallback;
+    }
+    const parsed = parseStoredData(value);
+    if (!parsed.ok) {
+        return fallback;
+    }
+    return parsed.value;
+};
+const toKeyArray = (keys) => {
+    const list = keys;
+    let size = 0;
+    if (typeof list?.size === 'function') {
+        size = Number(list.size());
+    }
+    else if (typeof list?.length === 'number') {
+        size = list.length;
+    }
+    const values = [];
+    let index = 0;
+    while (index < size) {
+        const valueAtIndex = typeof list.get === 'function' ? list.get(index) : list[index];
+        values.push(String(valueAtIndex));
+        index += 1;
+    }
+    return values;
+};
+const normalizeKey = (fullKey, prefix) => (fullKey.indexOf(prefix) === 0 ? fullKey.slice(prefix.length) : fullKey);
+export const logConfigValues = ({ action, group, getAllValues, keyPrefix = '' }) => {
+    try {
+        const valuesByKey = getAllValues(keyPrefix);
+        bot.printLogMessage(`${action} ${group} all values: ${JSON.stringify(valuesByKey)}`);
+        return valuesByKey;
+    }
+    catch (error) {
+        bot.printLogMessage(`${action} ${group} all values failed: ${String(error)}`);
+        return {};
+    }
+};
+export const createConfigScope = (options) => {
+    const group = parseGroupName(options.group);
+    const scope = parseConfigScopeMode(options.scope ?? 'profile');
+    const profileKey = parseOptionalProfileKey(options.profileKey);
+    const syncDefault = parseSyncDefault(options.syncDefault);
+    if (scope === 'group' && profileKey !== undefined) {
+        logAndThrowTypeError(PROFILE_KEY_WITH_GROUP_SCOPE_ERROR);
+    }
+    const groupKeyPrefix = `${group}.`;
+    const profileGroupName = profileKey ? buildProfileGroupName(group, profileKey) : null;
+    const profileGroupKeyPrefix = profileGroupName ? `${profileGroupName}.` : null;
+    const usesActiveProfile = () => Boolean(profileKey) && profileKey === getProfileKey();
+    const getString = (key, fallback = '') => {
+        if (scope === 'group') {
+            return getGroupString(group, key, fallback);
+        }
+        if (profileKey) {
+            return getProfileStringForProfileKey(group, profileKey, key, fallback);
+        }
+        return getProfileString(group, key, fallback);
+    };
+    const getKeys = (keyPrefix = '') => {
+        let fullKeys;
+        let prefixToTrim = groupKeyPrefix;
+        if (scope === 'group') {
+            fullKeys = toKeyArray(getGroupKeys(groupKeyPrefix));
+        }
+        else if (profileGroupName && profileGroupKeyPrefix) {
+            if (usesActiveProfile()) {
+                fullKeys = toKeyArray(getProfileConfigKeys(group, keyPrefix));
+            }
+            else {
+                fullKeys = toKeyArray(getGroupKeys(profileGroupKeyPrefix));
+                prefixToTrim = profileGroupKeyPrefix;
+            }
+        }
+        else {
+            fullKeys = toKeyArray(getProfileConfigKeys(group, keyPrefix));
+        }
+        const normalized = fullKeys.map((fullKey) => normalizeKey(fullKey, prefixToTrim)).filter((key) => key.length > 0);
+        if (!keyPrefix) {
+            return normalized;
+        }
+        return normalized.filter((key) => key.startsWith(keyPrefix));
+    };
+    const getAllValues = (keyPrefix = '') => {
+        const valuesByKey = {};
+        getKeys(keyPrefix).forEach((key) => {
+            valuesByKey[key] = getString(key, '');
+        });
+        return valuesByKey;
+    };
+    const logAllValues = (action, keyPrefix = '') => logConfigValues({ action, group, getAllValues, keyPrefix });
+    const set = (key, value, writeOptions) => {
+        const resolvedOptions = withSyncDefault(syncDefault, writeOptions);
+        if (scope === 'group') {
+            setGroupValue(group, key, value, resolvedOptions);
+            return;
+        }
+        if (profileKey) {
+            if (usesActiveProfile()) {
+                setProfileValue(group, key, value, resolvedOptions);
+                return;
+            }
+            setGroupValue(buildProfileGroupName(group, profileKey), key, value, resolvedOptions);
+            return;
+        }
+        setProfileValue(group, key, value, resolvedOptions);
+    };
+    const getNumber = (key, fallback = 0) => {
+        if (scope === 'group') {
+            return getGroupNumber(group, key, fallback);
+        }
+        if (profileKey) {
+            const parsed = parseNumber(getString(key, ''));
+            return parsed === null ? fallback : parsed;
+        }
+        return getProfileNumber(group, key, fallback);
+    };
+    const getInt = (key, fallback = 0) => {
+        if (scope === 'group') {
+            return getGroupInt(group, key, fallback);
+        }
+        if (profileKey) {
+            return getProfileIntForProfileKey(group, profileKey, key, fallback);
+        }
+        return getProfileInt(group, key, fallback);
+    };
+    const getFloat = (key, fallback = 0) => {
+        if (scope === 'group') {
+            return getGroupFloat(group, key, fallback);
+        }
+        if (profileKey) {
+            const parsed = parseFloatNumber(getString(key, ''));
+            return parsed === null ? fallback : parsed;
+        }
+        return getProfileFloat(group, key, fallback);
+    };
+    const getBoolean = (key, fallback = false) => {
+        if (scope === 'group') {
+            return getGroupBoolean(group, key, fallback);
+        }
+        if (profileKey) {
+            return getProfileBooleanForProfileKey(group, profileKey, key, fallback);
+        }
+        return getProfileBoolean(group, key, fallback);
+    };
+    const getStringArray = (key, fallback = []) => {
+        if (scope === 'group') {
+            return getGroupStringArray(group, key, fallback);
+        }
+        if (profileKey) {
+            const rawValue = getString(key, '');
+            if (!rawValue.trim()) {
+                return fallback;
+            }
+            const entries = parseStringArrayValue(rawValue);
+            return entries.length > 0 ? entries : fallback;
+        }
+        return getProfileStringArray(group, key, fallback);
+    };
+    const getNumberArray = (key, fallback = []) => {
+        if (scope === 'group') {
+            return getGroupNumberArray(group, key, fallback);
+        }
+        if (profileKey) {
+            return parseNumberArrayFromString(getString(key, ''), fallback);
+        }
+        return getProfileNumberArray(group, key, fallback);
+    };
+    const getJson = (key, fallback) => {
+        if (scope === 'group') {
+            return getGroupJson(group, key, fallback);
+        }
+        if (profileKey) {
+            return parseJsonFromString(getString(key, ''), fallback);
+        }
+        return getProfileJson(group, key, fallback);
+    };
+    const unset = (key, writeOptions) => {
+        const resolvedOptions = withSyncDefault(syncDefault, writeOptions);
+        if (scope === 'group') {
+            unsetGroupValue(group, key, resolvedOptions);
+            return;
+        }
+        if (profileKey) {
+            if (usesActiveProfile()) {
+                unsetProfileValue(group, key, resolvedOptions);
+                return;
+            }
+            unsetGroupValue(buildProfileGroupName(group, profileKey), key, resolvedOptions);
+            return;
+        }
+        unsetProfileValue(group, key, resolvedOptions);
+    };
+    return {
+        getKeys,
+        getAllValues,
+        logAllValues,
+        getString,
+        set,
+        getNumber,
+        getInt,
+        getFloat,
+        getBoolean,
+        getStringArray,
+        getNumberArray,
+        getJson,
+        unset,
+    };
+};

package/dist/data/group/aliases.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export type ConfigAliasValue = number[] | string;
+export declare const getGroupValue: (groupName: string, key: string) => ConfigAliasValue;
+export declare const setGroupValue: (groupName: string, key: string, value: unknown, options?: ConfigWriteOptions) => void;

package/dist/data/group/aliases.js

@@ -0,0 +1,17 @@
+import { isNumberArray, parseStoredData, toStoredJson } from '../shared/storage.js';
+import { getGroupString, setGroupString } from './strings.js';
+const parseAliasValue = (rawValue) => {
+    if (!rawValue.trim()) {
+        return [];
+    }
+    const parsed = parseStoredData(rawValue);
+    if (parsed.ok && typeof parsed.value === 'string') {
+        return parsed.value;
+    }
+    if (parsed.ok && isNumberArray(parsed.value)) {
+        return parsed.value;
+    }
+    return rawValue;
+};
+export const getGroupValue = (groupName, key) => parseAliasValue(getGroupString(groupName, key, ''));
+export const setGroupValue = (groupName, key, value, options) => setGroupString(groupName, key, toStoredJson(value), options);

package/dist/data/group/booleans.d.ts

@@ -0,0 +1,2 @@
+export declare const getGroupBoolean: (groupName: string, key: string, fallback?: boolean | undefined) => boolean;
+export declare const setGroupBoolean: (groupName: string, key: string, value: boolean, options?: import("../shared/types.js").ConfigWriteOptions | undefined) => void;

package/dist/data/group/booleans.js

@@ -0,0 +1,5 @@
+import { createBooleanAccessors } from '../shared/accessors.js';
+import { getGroupString, setGroupString } from './strings.js';
+const booleanAccessors = createBooleanAccessors(getGroupString, setGroupString);
+export const getGroupBoolean = booleanAccessors.getBoolean;
+export const setGroupBoolean = booleanAccessors.setBoolean;

package/dist/data/group/json.d.ts

@@ -0,0 +1,2 @@
+export declare const getGroupJson: <T>(groupName: string, key: string, fallback: T) => T;
+export declare const setGroupJson: <T>(groupName: string, key: string, value: T, options?: import("../shared/types.js").ConfigWriteOptions | undefined) => void;

package/dist/data/group/json.js

@@ -0,0 +1,5 @@
+import { createJsonAccessors } from '../shared/accessors.js';
+import { getGroupRawValue, setGroupString } from './strings.js';
+const jsonAccessors = createJsonAccessors(getGroupRawValue, setGroupString);
+export const getGroupJson = jsonAccessors.getJson;
+export const setGroupJson = jsonAccessors.setJson;

package/dist/data/group/keys.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export declare const unsetGroupValue: (groupName: string, key: string, options?: ConfigWriteOptions) => void;
+export declare const getGroupKeys: (prefix: string) => string[];
+export declare const sendConfig: () => void;

package/dist/data/group/keys.js

@@ -0,0 +1,10 @@
+import { writeConfig } from '../shared/write-config.js';
+export const unsetGroupValue = (groupName, key, options) => {
+    writeConfig(() => {
+        configManager.unsetConfiguration(groupName, key);
+    }, options);
+};
+export const getGroupKeys = (prefix) => configManager.getConfigurationKeys(prefix);
+export const sendConfig = () => {
+    configManager.sendConfig();
+};

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

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

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

@@ -0,0 +1,5 @@
+import { createNumberArrayAccessors } from '../shared/accessors.js';
+import { getGroupString, setGroupString } from './strings.js';
+const numberArrayAccessors = createNumberArrayAccessors(getGroupString, setGroupString);
+export const getGroupNumberArray = numberArrayAccessors.getNumberArray;
+export const setGroupNumberArray = numberArrayAccessors.setNumberArray;

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

@@ -0,0 +1,4 @@
+export declare const getGroupNumber: (groupName: string, key: string, fallback?: number | undefined) => number;
+export declare const getGroupInt: (groupName: string, key: string, fallback?: number | undefined) => number;
+export declare const getGroupFloat: (groupName: string, key: string, fallback?: number | undefined) => number;
+export declare const setGroupNumber: (groupName: string, key: string, value: number, options?: import("../shared/types.js").ConfigWriteOptions | undefined) => void;

package/dist/data/group/numbers.js

@@ -0,0 +1,7 @@
+import { createNumberAccessors } from '../shared/accessors.js';
+import { getGroupString, setGroupString } from './strings.js';
+const numberAccessors = createNumberAccessors(getGroupString, setGroupString);
+export const getGroupNumber = numberAccessors.getNumber;
+export const getGroupInt = numberAccessors.getInt;
+export const getGroupFloat = numberAccessors.getFloat;
+export const setGroupNumber = numberAccessors.setNumber;

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

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

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

@@ -0,0 +1,5 @@
+import { createStringArrayAccessors } from '../shared/accessors.js';
+import { getGroupString, setGroupString } from './strings.js';
+const stringArrayAccessors = createStringArrayAccessors(getGroupString, setGroupString);
+export const getGroupStringArray = stringArrayAccessors.getStringArray;
+export const setGroupStringArray = stringArrayAccessors.setStringArray;

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

@@ -0,0 +1,4 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export declare const getGroupRawValue: (groupName: string, key: string) => string | null;
+export declare const getGroupString: (groupName: string, key: string, fallback?: string) => string;
+export declare const setGroupString: (groupName: string, key: string, value: string, options?: ConfigWriteOptions) => void;

package/dist/data/group/strings.js

@@ -0,0 +1,26 @@
+import { normalizeConfigValue } from '../shared/normalize-config-value.js';
+import { parseStoredData } from '../shared/storage.js';
+import { writeConfig } from '../shared/write-config.js';
+export const getGroupRawValue = (groupName, key) => {
+    const rawValue = normalizeConfigValue(configManager.getConfiguration(groupName, key));
+    if (rawValue === null || rawValue === undefined) {
+        return null;
+    }
+    return rawValue;
+};
+export const getGroupString = (groupName, key, fallback = '') => {
+    const rawValue = getGroupRawValue(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 setGroupString = (groupName, key, value, options) => {
+    writeConfig(() => {
+        configManager.setConfiguration(groupName, key, value);
+    }, options);
+};

package/dist/data/group/summary.d.ts

@@ -0,0 +1 @@
+export declare const logGroupConfigSummary: (groupName: string) => void;

package/dist/data/group/summary.js

@@ -0,0 +1,30 @@
+import { RS_PROFILE_GROUP_SEGMENT } from '../shared/profile-group.js';
+import { getGroupKeys } from './keys.js';
+export const logGroupConfigSummary = (groupName) => {
+    const keys = getGroupKeys(`${groupName}.`);
+    if (keys.length === 0) {
+        log.printGameMessage(`No config keys found for group '${groupName}'.`);
+        return;
+    }
+    const profilePrefix = `${groupName}${RS_PROFILE_GROUP_SEGMENT}`;
+    const groupScoped = [];
+    let profileScopedCount = 0;
+    keys.forEach((key) => {
+        if (key.startsWith(profilePrefix)) {
+            profileScopedCount += 1;
+        }
+        else {
+            groupScoped.push(key);
+        }
+    });
+    log.printGameMessage(`Config summary for group '${groupName}': ${keys.length} total key(s), ${groupScoped.length} group-level, ${profileScopedCount} profile-scoped.`);
+    if (groupScoped.length > 0) {
+        const sortedKeys = groupScoped.slice().sort((a, b) => a.localeCompare(b));
+        sortedKeys.forEach((key) => {
+            log.printGameMessage(`Group-level key: ${key}`);
+        });
+    }
+    if (profileScopedCount > 0) {
+        log.printGameMessage(`Profile-scoped keys detected for '${groupName}'. Use profile.logSummary('${groupName}') for details.`);
+    }
+};

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

@@ -0,0 +1,5 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export declare const getProfileBoolean: (groupName: string, key: string, fallback?: boolean | undefined) => boolean;
+export declare const setProfileBoolean: (groupName: string, key: string, value: boolean, options?: ConfigWriteOptions | undefined) => void;
+export declare const getProfileBooleanForProfileKey: (groupName: string, profileKey: string, key: string, fallback?: boolean) => boolean;
+export declare const setProfileBooleanForProfileKey: (groupName: string, profileKey: string, key: string, value: boolean, options?: ConfigWriteOptions) => void;

package/dist/data/profile/booleans.js

@@ -0,0 +1,11 @@
+import { createBooleanAccessors, parseStoredBoolean } from '../shared/accessors.js';
+import { getProfileString, getProfileStringForProfileKey, setProfileString, setProfileStringForProfileKey } from './strings.js';
+const booleanAccessors = createBooleanAccessors(getProfileString, setProfileString);
+export const getProfileBoolean = booleanAccessors.getBoolean;
+export const setProfileBoolean = booleanAccessors.setBoolean;
+export const getProfileBooleanForProfileKey = (groupName, profileKey, key, fallback = false) => {
+    return parseStoredBoolean(getProfileStringForProfileKey(groupName, profileKey, key, ''), fallback);
+};
+export const setProfileBooleanForProfileKey = (groupName, profileKey, key, value, options) => {
+    setProfileStringForProfileKey(groupName, profileKey, key, value ? 'true' : 'false', options);
+};

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

@@ -0,0 +1,5 @@
+import type { ConfigWriteOptions } from '../shared/types.js';
+export declare const unsetProfileValue: (groupName: string, key: string, options?: ConfigWriteOptions) => void;
+export type ProfileConfigAliasValue = number[] | string;
+export declare const getProfileValue: (groupName: string, key: string) => ProfileConfigAliasValue;
+export declare const setProfileValue: (groupName: string, key: string, value: unknown, options?: ConfigWriteOptions) => void;

package/dist/data/profile/config.js

@@ -0,0 +1,23 @@
+import { isNumberArray, parseStoredData, toStoredJson } from '../shared/storage.js';
+import { writeConfig } from '../shared/write-config.js';
+import { getProfileString, setProfileString } from './strings.js';
+export const unsetProfileValue = (groupName, key, options) => {
+    writeConfig(() => {
+        configManager.unsetRSProfileConfiguration(groupName, key);
+    }, options);
+};
+const parseAliasValue = (rawValue) => {
+    if (!rawValue.trim()) {
+        return [];
+    }
+    const parsed = parseStoredData(rawValue);
+    if (parsed.ok && typeof parsed.value === 'string') {
+        return parsed.value;
+    }
+    if (parsed.ok && isNumberArray(parsed.value)) {
+        return parsed.value;
+    }
+    return rawValue;
+};
+export const getProfileValue = (groupName, key) => parseAliasValue(getProfileString(groupName, key, ''));
+export const setProfileValue = (groupName, key, value, options) => setProfileString(groupName, key, toStoredJson(value), options);

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

@@ -0,0 +1,2 @@
+export declare const getProfileJson: <T>(groupName: string, key: string, fallback: T) => T;
+export declare const setProfileJson: <T>(groupName: string, key: string, value: T, options?: import("../shared/types.js").ConfigWriteOptions | undefined) => void;

package/dist/data/profile/json.js

@@ -0,0 +1,5 @@
+import { createJsonAccessors } from '../shared/accessors.js';
+import { getProfileRawValue, setProfileString } from './strings.js';
+const jsonAccessors = createJsonAccessors(getProfileRawValue, setProfileString);
+export const getProfileJson = jsonAccessors.getJson;
+export const setProfileJson = jsonAccessors.setJson;

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

@@ -0,0 +1,5 @@
+export declare const getProfileKey: () => string;
+export declare const getProfileGroupName: (groupName: string, profileKey: string) => string;
+export declare const getProfileKeysForGroup: (groupName: string) => string[];
+export declare const logProfileConfigSummary: (groupName: string) => void;
+export declare const getProfileConfigKeys: (groupName: string, keyPrefix?: string) => string[];