@difizen/mana-core
Version:
342 lines (340 loc) • 15 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ConfigurationTarget = void 0;
exports.ConfigurationTargetToString = ConfigurationTargetToString;
exports.IConfigurationService = void 0;
exports.addToValueTree = addToValueTree;
exports.compare = compare;
exports.getConfigurationKeys = getConfigurationKeys;
exports.getConfigurationValue = getConfigurationValue;
exports.getDefaultValues = getDefaultValues;
exports.getMigratedSettingValue = getMigratedSettingValue;
exports.isConfigurationOverrides = isConfigurationOverrides;
exports.keyFromOverrideIdentifier = keyFromOverrideIdentifier;
exports.merge = merge;
exports.removeFromValueTree = removeFromValueTree;
exports.toOverrides = toOverrides;
exports.toValuesTree = toValuesTree;
var _manaCommon = require("@difizen/mana-common");
var _manaSyringe = require("@difizen/mana-syringe");
var _platform = require("../platform");
var _configurationRegistry = require("./configurationRegistry");
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } /*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ // import type { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
// import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
// export const IConfigurationService = createDecorator<IConfigurationService>('configurationService');
var IConfigurationService = exports.IConfigurationService = _manaSyringe.Syringe.defineToken('IConfigurationService');
function isConfigurationOverrides(thing) {
return thing && _typeof(thing) === 'object' && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string') && (!thing.resource || thing.resource instanceof _manaCommon.URI);
}
var ConfigurationTarget = exports.ConfigurationTarget = /*#__PURE__*/function (ConfigurationTarget) {
ConfigurationTarget[ConfigurationTarget["USER"] = 1] = "USER";
ConfigurationTarget[ConfigurationTarget["USER_LOCAL"] = 2] = "USER_LOCAL";
ConfigurationTarget[ConfigurationTarget["USER_REMOTE"] = 3] = "USER_REMOTE";
ConfigurationTarget[ConfigurationTarget["WORKSPACE"] = 4] = "WORKSPACE";
ConfigurationTarget[ConfigurationTarget["WORKSPACE_FOLDER"] = 5] = "WORKSPACE_FOLDER";
ConfigurationTarget[ConfigurationTarget["DEFAULT"] = 6] = "DEFAULT";
ConfigurationTarget[ConfigurationTarget["MEMORY"] = 7] = "MEMORY";
return ConfigurationTarget;
}({});
function ConfigurationTargetToString(configurationTarget) {
switch (configurationTarget) {
case ConfigurationTarget.USER:
return 'USER';
case ConfigurationTarget.USER_LOCAL:
return 'USER_LOCAL';
case ConfigurationTarget.USER_REMOTE:
return 'USER_REMOTE';
case ConfigurationTarget.WORKSPACE:
return 'WORKSPACE';
case ConfigurationTarget.WORKSPACE_FOLDER:
return 'WORKSPACE_FOLDER';
case ConfigurationTarget.DEFAULT:
return 'DEFAULT';
case ConfigurationTarget.MEMORY:
return 'MEMORY';
}
}
function compare(from, to) {
var added = to ? from ? to.keys.filter(function (key) {
return from.keys.indexOf(key) === -1;
}) : _toConsumableArray(to.keys) : [];
var removed = from ? to ? from.keys.filter(function (key) {
return to.keys.indexOf(key) === -1;
}) : _toConsumableArray(from.keys) : [];
var updated = [];
if (to && from) {
var _iterator = _createForOfIteratorHelper(from.keys),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var _key = _step.value;
if (to.keys.indexOf(_key) !== -1) {
var value1 = getConfigurationValue(from.contents, _key);
var value2 = getConfigurationValue(to.contents, _key);
if (!_manaCommon.objects.objectEquals(value1, value2)) {
updated.push(_key);
}
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
}
var overrides = [];
var byOverrideIdentifier = function byOverrideIdentifier(overrides) {
var result = {};
var _iterator2 = _createForOfIteratorHelper(overrides),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var override = _step2.value;
var _iterator3 = _createForOfIteratorHelper(override.identifiers),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var identifier = _step3.value;
result[keyFromOverrideIdentifier(identifier)] = override;
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
return result;
};
var toOverridesByIdentifier = to ? byOverrideIdentifier(to.overrides) : {};
var fromOverridesByIdentifier = from ? byOverrideIdentifier(from.overrides) : {};
if (Object.keys(toOverridesByIdentifier).length) {
var _iterator4 = _createForOfIteratorHelper(added),
_step4;
try {
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
var _key2 = _step4.value;
var override = toOverridesByIdentifier[_key2];
if (override) {
overrides.push([(0, _configurationRegistry.overrideIdentifierFromKey)(_key2), override.keys]);
}
}
} catch (err) {
_iterator4.e(err);
} finally {
_iterator4.f();
}
}
if (Object.keys(fromOverridesByIdentifier).length) {
var _iterator5 = _createForOfIteratorHelper(removed),
_step5;
try {
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
var _key3 = _step5.value;
var _override = fromOverridesByIdentifier[_key3];
if (_override) {
overrides.push([(0, _configurationRegistry.overrideIdentifierFromKey)(_key3), _override.keys]);
}
}
} catch (err) {
_iterator5.e(err);
} finally {
_iterator5.f();
}
}
if (Object.keys(toOverridesByIdentifier).length && Object.keys(fromOverridesByIdentifier).length) {
var _iterator6 = _createForOfIteratorHelper(updated),
_step6;
try {
for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
var _key4 = _step6.value;
var fromOverride = fromOverridesByIdentifier[_key4];
var toOverride = toOverridesByIdentifier[_key4];
if (fromOverride && toOverride) {
var result = compare({
contents: fromOverride.contents,
keys: fromOverride.keys,
overrides: []
}, {
contents: toOverride.contents,
keys: toOverride.keys,
overrides: []
});
overrides.push([(0, _configurationRegistry.overrideIdentifierFromKey)(_key4), [].concat(_toConsumableArray(result.added), _toConsumableArray(result.removed), _toConsumableArray(result.updated))]);
}
}
} catch (err) {
_iterator6.e(err);
} finally {
_iterator6.f();
}
}
return {
added: added,
removed: removed,
updated: updated,
overrides: overrides
};
}
function toOverrides(raw, conflictReporter) {
var overrides = [];
for (var _i = 0, _Object$keys = Object.keys(raw); _i < _Object$keys.length; _i++) {
var _key5 = _Object$keys[_i];
if (_configurationRegistry.OVERRIDE_PROPERTY_PATTERN.test(_key5)) {
var overrideRaw = {};
for (var keyInOverrideRaw in raw[_key5]) {
overrideRaw[keyInOverrideRaw] = raw[_key5][keyInOverrideRaw];
}
overrides.push({
identifiers: [(0, _configurationRegistry.overrideIdentifierFromKey)(_key5).trim()],
keys: Object.keys(overrideRaw),
contents: toValuesTree(overrideRaw, conflictReporter)
});
}
}
return overrides;
}
function toValuesTree(properties, conflictReporter) {
var root = Object.create(null);
for (var _key6 in properties) {
addToValueTree(root, _key6, properties[_key6], conflictReporter);
}
return root;
}
function addToValueTree(settingsTreeRoot, key, value, conflictReporter) {
var segments = key.split('.');
var last = segments.pop();
var curr = settingsTreeRoot;
for (var i = 0; i < segments.length; i++) {
var s = segments[i];
var obj = curr[s];
switch (_typeof(obj)) {
case 'undefined':
obj = curr[s] = Object.create(null);
break;
case 'object':
break;
default:
conflictReporter("Ignoring ".concat(key, " as ").concat(segments.slice(0, i + 1).join('.'), " is ").concat(JSON.stringify(obj)));
return;
}
curr = obj;
}
if (_typeof(curr) === 'object' && curr !== null) {
try {
curr[last] = value; // workaround https://github.com/microsoft/vscode/issues/13606
} catch (e) {
conflictReporter("Ignoring ".concat(key, " as ").concat(segments.join('.'), " is ").concat(JSON.stringify(curr)));
}
} else {
conflictReporter("Ignoring ".concat(key, " as ").concat(segments.join('.'), " is ").concat(JSON.stringify(curr)));
}
}
function removeFromValueTree(valueTree, key) {
var segments = key.split('.');
doRemoveFromValueTree(valueTree, segments);
}
function doRemoveFromValueTree(valueTree, segments) {
var first = segments.shift();
if (segments.length === 0) {
// Reached last segment
delete valueTree[first];
return;
}
if (Object.keys(valueTree).indexOf(first) !== -1) {
var _value = valueTree[first];
if (_typeof(_value) === 'object' && !Array.isArray(_value)) {
doRemoveFromValueTree(_value, segments);
if (Object.keys(_value).length === 0) {
delete valueTree[first];
}
}
}
}
/**
* A helper function to get the configuration value with a specific settings path (e.g. config.some.setting)
*/
function getConfigurationValue(config, settingPath, defaultValue) {
function accessSetting(config, path) {
var current = config;
var _iterator7 = _createForOfIteratorHelper(path),
_step7;
try {
for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
var component = _step7.value;
if (_typeof(current) !== 'object' || current === null) {
return undefined;
}
current = current[component];
}
} catch (err) {
_iterator7.e(err);
} finally {
_iterator7.f();
}
return current;
}
var path = settingPath.split('.');
var result = accessSetting(config, path);
return typeof result === 'undefined' ? defaultValue : result;
}
function merge(base, add, overwrite) {
Object.keys(add).forEach(function (key) {
if (key !== '__proto__') {
if (key in base) {
if (_manaCommon.types.isObject(base[key]) && _manaCommon.types.isObject(add[key])) {
merge(base[key], add[key], overwrite);
} else if (overwrite) {
base[key] = add[key];
}
} else {
base[key] = add[key];
}
}
});
}
function getConfigurationKeys() {
var properties = _platform.Registry.as(_configurationRegistry.Extensions.Configuration).getConfigurationProperties();
return Object.keys(properties);
}
function getDefaultValues() {
var valueTreeRoot = Object.create(null);
var properties = _platform.Registry.as(_configurationRegistry.Extensions.Configuration).getConfigurationProperties();
for (var _key7 in properties) {
var _value2 = properties[_key7].default;
addToValueTree(valueTreeRoot, _key7, _value2, function (message) {
return console.error("Conflict in default settings: ".concat(message));
});
}
return valueTreeRoot;
}
function keyFromOverrideIdentifier(overrideIdentifier) {
return "[".concat(overrideIdentifier, "]");
}
function getMigratedSettingValue(configurationService, currentSettingName, legacySettingName) {
var setting = configurationService.inspect(currentSettingName);
var legacySetting = configurationService.inspect(legacySettingName);
if (typeof setting.userValue !== 'undefined' || typeof setting.workspaceValue !== 'undefined' || typeof setting.workspaceFolderValue !== 'undefined') {
return setting.value;
}
if (typeof legacySetting.userValue !== 'undefined' || typeof legacySetting.workspaceValue !== 'undefined' || typeof legacySetting.workspaceFolderValue !== 'undefined') {
return legacySetting.value;
}
return setting.defaultValue;
}