Les contraintes iframe imposent que tu ne mélange pas du http et du https dans la même page et obligent à garder le même domaine. Donc en fonction de ce que tu veux ajouter, ça pose problème.
Par ailleurs, puisque tu passes pas un RPX, les urls internes (https://192.168.x.x par exemple) ne sera pas utilisables depuis un accès externe.
Merci @Pulpy-Luke
Très clair.
Voici mon retour d’expériences pour les autres utilisateurs intéressés par le sujet :
- Le module
custom_sidebarvia HACS semble le plus polyvalent et le plus riche mais je n’ai pas réussi à le faire fonctionner
https://forum.hacf.fr/t/module-modification-de-la-barre-laterale/1732/15?u=turingfan
- L’utilisation de panel_iframe est contrainte et affiche la sidebar dans la fenêtre appelée ce qui fait donc doublon
https://forum.hacf.fr/t/module-modification-de-la-barre-laterale/1732/22?u=turingfan
- L’utilisation de panel_custom semble fonctionner pour moi pour de simples raccourcis (vers les intégrations, les addons, les automations, etc.). Il est apparemment alors possible de développer ses propres panneaux en JavaScript mais cela me dépasse de très loin.
En revanche je ne sais pas comment appliquer ces modifications à un type spécifique d’appareils (PC vs. smartphones/tablettes) et/ou d’utilisateurs (admin, non admin, user spécifique, etc.).
Preneur d’aide si quelqu’un sait faire ?
Pour ce qui touche au frontend de HA, un des spécialistes se nomme @Clemalex mais je sais qu’il est pas mal pris en ce moment alors ne lui en demande pas trop 
1 « J'aime »
PS : j’ai l’impression que les changements faits via la méthode native ne sont pas persistants et sont remis à zéro à chaque fois je que je me déconnecte et reconnecte.
C’est lié à ton profil et à la session. Donc si l’un ou l’autre change, alors oui il faut refaire la config
Concernant le fait d’afficher ou non une page, à ta place je passerai plus par les vues (cf les options d’édition)
après ça reste un avis personnel, mais autant je fais le distinguo entre le profils utilisateur (chacun son login de toute façon), autant je veux les même choses sur la tablette, le pc ou le téléphone
1 « J'aime »
Je vais effectivement déjà essayer ça.
Par contre j’ai toujours une remise à zéro des « hide » et « order » natifs de ma barre latérale quand je me déconnecte puis reconnecte …
C’est normal… cf la première partie de ma réponse au dessus
Du coup aucun moyen de cacher ou de changer l’ordre des éléments de la sidecar durablement pour un même user ?
Tu te déconnectes pas 
1 « J'aime »
Bonjour,
Pour ceux intéressés par le « custom-sidebar », il n’est pas maintenu par son développeur depuis longtemps. J’ai pu l’adapter pour la dernière version de HA 2023.6.3.
Le nouveau fichier JS est ci-dessous.
Attention, j’ai modifié aussi dans le script le chemin vers le fichier « sidebar-order.yaml » pour les mettre dans le même répertoire. 
Bon usage.
Bibi
custom-sidebar.js
console.log("Custom Sidebar is loading");
var Hacky_Hackerson = setInterval(run, 1000 / 60);
var Loaded = false;
var Haobj = null;
var Root = null;
var TitleElement = null;
function Current_Order(config) {
var return_order = null;
if (config) {
if(config.title){
setTitle(config.title);
}
if (config.order) {
return_order = config.order;
}
if (config.exceptions) {
for (var i = 0; i < config.exceptions.length; i++) {
var current_exception = config.exceptions[i];
var current_environment_enabled = true;
var current_exception_keys = Object.keys(current_exception);
for (var x = 0; x < current_exception_keys.length; x++) {
console.log(navigator.userAgent);
switch (current_exception_keys[x]) {
case "user":
if(current_exception.user.includes(',')){
current_exception.user = current_exception.user.replace(/, /g, ',').split(',');
}
if (current_exception.user instanceof Array) {
current_environment_enabled = current_exception.user.map(x => x.toLowerCase()).some(x => x == Haobj.user.name.toLowerCase());
}
else {
if (current_exception.user.toLowerCase() != Haobj.user.name.toLowerCase()) {
current_environment_enabled = false;
}
}
break;
case "device":
if(current_exception.device.includes(',')){
current_exception.device = current_exception.device.replace(/, /g, ',').split(',');
}
if (current_exception.device instanceof Array) {
current_environment_enabled = false;
current_exception.device.forEach(device=>{
if (navigator.userAgent.toLowerCase().includes(device.toLowerCase())) {
current_environment_enabled = true;
}
});
}
else {
if (!navigator.userAgent.toLowerCase().includes(current_exception.device.toLowerCase())) {
current_environment_enabled = false;
}
}
break;
case "not_user":
if(current_exception.not_user.includes(',')){
current_exception.not_user = current_exception.not_user.replace(/, /g, ',').split(',');
}
if (current_exception.not_user instanceof Array) {
current_environment_enabled = !current_exception.not_user.map(x => x.toLowerCase()).some(x => x == Haobj.user.name.toLowerCase());
}
else {
if (current_exception.not_user.toLowerCase() == Haobj.user.name.toLowerCase()) {
current_environment_enabled = false;
}
}
break;
case "not_device":
if(current_exception.not_device.includes(',')){
current_exception.not_device = current_exception.not_device.replace(/, /g, ',').split(',');
}
if (current_exception.not_device instanceof Array) {
current_exception.not_device.forEach(not_device=>{
if (navigator.userAgent.toLowerCase().includes(not_device.toLowerCase())) {
current_environment_enabled = false;
}
});
}
else {
if (navigator.userAgent.toLowerCase().includes(current_exception.not_device.toLowerCase())) {
current_environment_enabled = false;
}
}
break;
}
if (current_environment_enabled == false) {
break;
}
}
if (current_environment_enabled) {
if (current_exception.order) {
if (current_exception.base_order && return_order) {
rearrange(return_order);
}
return_order = current_exception.order;
}
}
}
}
}
return return_order;
}
function rearrange(order) {
if (order) {
for (var i = order.length - 1; i >= 0; i--) {
if (order[i].new_item == true) {
createItem(Root, order[i]);
}
}
for (var i = order.length - 1; i >= 0; i--) {
moveItem(Root, order[i]);
}
}
}
function setTitle(title){
if(TitleElement){
TitleElement.innerHTML = title;
}
}
function run() {
Root = getSidebar();
if (Root && !Loaded) {
Loaded = true;
var req = new XMLHttpRequest();
req.onload = function () {
var order = Current_Order(YAML.parse(this.responseText));
rearrange(order);
clearInterval(Hacky_Hackerson)
console.log("Custom Sidebar is loaded");
};
req.onerror = function () {
clearInterval(Hacky_Hackerson);
}
req.open("GET", "/local/resources/pack_core/custom-sidebar/sidebar-order.yaml?rnd=" + rando());
req.send();
}
}
function getSidebar() {
let root = document.querySelector("home-assistant");
Haobj = root.hass;
root = root && root.shadowRoot;
root = root && root.querySelector("home-assistant-main");
root = root && root.shadowRoot;
root = root && root.querySelector("ha-drawer");
root = root && root.querySelector("ha-sidebar");
root = root && root.shadowRoot;
TitleElement = root && root.querySelector('.title') ? root.querySelector('.title') : null ;
root = root && root.querySelector("paper-listbox");
return root;
}
function createItem(elements, item) {
var cln = getConfigurationElement(elements).cloneNode(true);
if (cln) {
cln.querySelector("paper-icon-item").querySelector("ha-svg-icon").setAttribute("icon", item.icon);
cln.querySelector("paper-icon-item").querySelector("span").innerHTML = item.item;
cln.href = item.href;
cln.setAttribute("data-panel", item.item);
elements.insertBefore(cln, elements.children[0]);
}
}
function getConfigurationElement(elements) {
for (var i = 0; i < elements.children.length; i++) {
if (elements.children[i].tagName == "A") {
var current = elements.children[i].getAttribute("data-panel");
if (current == "config") {
return elements.children[i];
}
}
}
}
function moveItem(elements, config_entry) {
for (var i = 0; i < elements.children.length; i++) {
if (elements.children[i].tagName == "A") {
var current = elements.children[i].children[0].getElementsByTagName("span")[0].innerHTML.replace('<!---->', '').replace('<!---->', '');
var match = false;
if (config_entry.exact) {
match = current == config_entry.item;
} else {
match = current.toLowerCase().includes(config_entry.item.toLowerCase());
}
if (match) {
if (config_entry.href) {
elements.children[i].href = config_entry.href;
}
if (config_entry.name) {
elements.children[i].children[0].getElementsByTagName("span")[0].innerHTML = elements.children[i].children[0].getElementsByTagName("span")[0].innerHTML.replace(current, config_entry.name);
}
if (config_entry.icon) {
var icon_holder = elements.children[i].querySelector("ha-svg-icon");
if (icon_holder) {
icon_holder.setAttribute("icon", config_entry.icon);
} else {
var old_icon = elements.children[i].querySelector("ha-svg-icon");
if (old_icon) {
var icon_item = elements.children[i].querySelector("paper-icon-item");
icon_item.removeChild(old_icon);
icon_holder = document.createElement("ha-svg-icon");
icon_holder.setAttribute("slot", "item-icon");
icon_holder.setAttribute("icon", config_entry.icon);
icon_item.prepend(icon_holder);
}
}
}
if (config_entry.hide == true) {
elements.children[i].style.display = "none";
} else {
elements.children[i].style.display = "block";
if (config_entry.bottom == true) {
elements.insertBefore(elements.children[i], elements.querySelector("div").nextSibling);
} else {
elements.insertBefore(elements.children[i], elements.children[0]);
}
}
}
}
}
}
function rando() {
return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
}
//YAML parser taken from https://github.com/jeremyfa/yaml.js
(function () {
function r(e, n, t) {
function o(i, f) {
if (!n[i]) {
if (!e[i]) {
var c = "function" == typeof require && require;
if (!f && c) return c(i, !0);
if (u) return u(i, !0);
var a = new Error("Cannot find module '" + i + "'");
throw a.code = "MODULE_NOT_FOUND", a
}
var p = n[i] = {
exports: {}
};
e[i][0].call(p.exports, function (r) {
var n = e[i][1][r];
return o(n || r)
}, p, p.exports, r, e, n, t)
}
return n[i].exports
}
for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
return o
}
return r
})()({
1: [function (require, module, exports) {
var Dumper, Inline, Utils;
Utils = require('./Utils');
Inline = require('./Inline');
Dumper = (function () {
function Dumper() { }
Dumper.indentation = 4;
Dumper.prototype.dump = function (input, inline, indent, exceptionOnInvalidType, objectEncoder) {
var i, key, len, output, prefix, value, willBeInlined;
if (inline == null) {
inline = 0;
}
if (indent == null) {
indent = 0;
}
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectEncoder == null) {
objectEncoder = null;
}
output = '';
if (typeof input === 'function') {
return output;
}
prefix = (indent ? Utils.strRepeat(' ', indent) : '');
if (inline <= 0 || typeof input !== 'object' || input instanceof Date || Utils.isEmpty(input)) {
output += prefix + Inline.dump(input, exceptionOnInvalidType, objectEncoder);
} else {
if (input instanceof Array) {
for (i = 0, len = input.length; i < len; i++) {
value = input[i];
willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
output += prefix + '-' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
}
} else {
for (key in input) {
value = input[key];
willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
output += prefix + Inline.dump(key, exceptionOnInvalidType, objectEncoder) + ':' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
}
}
}
return output;
};
return Dumper;
})();
module.exports = Dumper;
}, {
"./Inline": 6,
"./Utils": 10
}],
2: [function (require, module, exports) {
var Escaper, Pattern;
Pattern = require('./Pattern');
Escaper = (function () {
var ch;
function Escaper() { }
Escaper.LIST_ESCAPEES = ['\\', '\\\\', '\\"', '"', "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\x09", "\x0a", "\x0b", "\x0c", "\x0d", "\x0e", "\x0f", "\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1a", "\x1b", "\x1c", "\x1d", "\x1e", "\x1f", (ch = String.fromCharCode)(0x0085), ch(0x00A0), ch(0x2028), ch(0x2029)];
Escaper.LIST_ESCAPED = ['\\\\', '\\"', '\\"', '\\"', "\\0", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\a", "\\b", "\\t", "\\n", "\\v", "\\f", "\\r", "\\x0e", "\\x0f", "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", "\\x18", "\\x19", "\\x1a", "\\e", "\\x1c", "\\x1d", "\\x1e", "\\x1f", "\\N", "\\_", "\\L", "\\P"];
Escaper.MAPPING_ESCAPEES_TO_ESCAPED = (function () {
var i, j, mapping, ref;
mapping = {};
for (i = j = 0, ref = Escaper.LIST_ESCAPEES.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
mapping[Escaper.LIST_ESCAPEES[i]] = Escaper.LIST_ESCAPED[i];
}
return mapping;
})();
Escaper.PATTERN_CHARACTERS_TO_ESCAPE = new Pattern('[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9');
Escaper.PATTERN_MAPPING_ESCAPEES = new Pattern(Escaper.LIST_ESCAPEES.join('|').split('\\').join('\\\\'));
Escaper.PATTERN_SINGLE_QUOTING = new Pattern('[\\s\'":{}[\\],&*#?]|^[-?|<>=!%@`]');
Escaper.requiresDoubleQuoting = function (value) {
return this.PATTERN_CHARACTERS_TO_ESCAPE.test(value);
};
Escaper.escapeWithDoubleQuotes = function (value) {
var result;
result = this.PATTERN_MAPPING_ESCAPEES.replace(value, (function (_this) {
return function (str) {
return _this.MAPPING_ESCAPEES_TO_ESCAPED[str];
};
})(this));
return '"' + result + '"';
};
Escaper.requiresSingleQuoting = function (value) {
return this.PATTERN_SINGLE_QUOTING.test(value);
};
Escaper.escapeWithSingleQuotes = function (value) {
return "'" + value.replace(/'/g, "''") + "'";
};
return Escaper;
})();
module.exports = Escaper;
}, {
"./Pattern": 8
}],
3: [function (require, module, exports) {
var DumpException,
extend = function (child, parent) {
for (var key in parent) {
if (hasProp.call(parent, key)) child[key] = parent[key];
}
function ctor() {
this.constructor = child;
}
ctor.prototype = parent.prototype;
child.prototype = new ctor();
child.__super__ = parent.prototype;
return child;
},
hasProp = {}.hasOwnProperty;
DumpException = (function (superClass) {
extend(DumpException, superClass);
function DumpException(message, parsedLine, snippet) {
DumpException.__super__.constructor.call(this, message);
this.message = message;
this.parsedLine = parsedLine;
this.snippet = snippet;
}
DumpException.prototype.toString = function () {
if ((this.parsedLine != null) && (this.snippet != null)) {
return '<DumpException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
} else {
return '<DumpException> ' + this.message;
}
};
return DumpException;
})(Error);
module.exports = DumpException;
}, {}],
4: [function (require, module, exports) {
var ParseException,
extend = function (child, parent) {
for (var key in parent) {
if (hasProp.call(parent, key)) child[key] = parent[key];
}
function ctor() {
this.constructor = child;
}
ctor.prototype = parent.prototype;
child.prototype = new ctor();
child.__super__ = parent.prototype;
return child;
},
hasProp = {}.hasOwnProperty;
ParseException = (function (superClass) {
extend(ParseException, superClass);
function ParseException(message, parsedLine, snippet) {
ParseException.__super__.constructor.call(this, message);
this.message = message;
this.parsedLine = parsedLine;
this.snippet = snippet;
}
ParseException.prototype.toString = function () {
if ((this.parsedLine != null) && (this.snippet != null)) {
return '<ParseException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
} else {
return '<ParseException> ' + this.message;
}
};
return ParseException;
})(Error);
module.exports = ParseException;
}, {}],
5: [function (require, module, exports) {
var ParseMore,
extend = function (child, parent) {
for (var key in parent) {
if (hasProp.call(parent, key)) child[key] = parent[key];
}
function ctor() {
this.constructor = child;
}
ctor.prototype = parent.prototype;
child.prototype = new ctor();
child.__super__ = parent.prototype;
return child;
},
hasProp = {}.hasOwnProperty;
ParseMore = (function (superClass) {
extend(ParseMore, superClass);
function ParseMore(message, parsedLine, snippet) {
ParseMore.__super__.constructor.call(this, message);
this.message = message;
this.parsedLine = parsedLine;
this.snippet = snippet;
}
ParseMore.prototype.toString = function () {
if ((this.parsedLine != null) && (this.snippet != null)) {
return '<ParseMore> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
} else {
return '<ParseMore> ' + this.message;
}
};
return ParseMore;
})(Error);
module.exports = ParseMore;
}, {}],
6: [function (require, module, exports) {
var DumpException, Escaper, Inline, ParseException, ParseMore, Pattern, Unescaper, Utils,
indexOf = [].indexOf || function (item) {
for (var i = 0, l = this.length; i < l; i++) {
if (i in this && this[i] === item) return i;
}
return -1;
};
Pattern = require('./Pattern');
Unescaper = require('./Unescaper');
Escaper = require('./Escaper');
Utils = require('./Utils');
ParseException = require('./Exception/ParseException');
ParseMore = require('./Exception/ParseMore');
DumpException = require('./Exception/DumpException');
Inline = (function () {
function Inline() { }
Inline.REGEX_QUOTED_STRING = '(?:"(?:[^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'(?:[^\']*(?:\'\'[^\']*)*)\')';
Inline.PATTERN_TRAILING_COMMENTS = new Pattern('^\\s*#.*$');
Inline.PATTERN_QUOTED_SCALAR = new Pattern('^' + Inline.REGEX_QUOTED_STRING);
Inline.PATTERN_THOUSAND_NUMERIC_SCALAR = new Pattern('^(-|\\+)?[0-9,]+(\\.[0-9]+)?$');
Inline.PATTERN_SCALAR_BY_DELIMITERS = {};
Inline.settings = {};
Inline.configure = function (exceptionOnInvalidType, objectDecoder) {
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = null;
}
if (objectDecoder == null) {
objectDecoder = null;
}
this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
this.settings.objectDecoder = objectDecoder;
};
Inline.parse = function (value, exceptionOnInvalidType, objectDecoder) {
var context, result;
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectDecoder == null) {
objectDecoder = null;
}
this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
this.settings.objectDecoder = objectDecoder;
if (value == null) {
return '';
}
value = Utils.trim(value);
if (0 === value.length) {
return '';
}
context = {
exceptionOnInvalidType: exceptionOnInvalidType,
objectDecoder: objectDecoder,
i: 0
};
switch (value.charAt(0)) {
case '[':
result = this.parseSequence(value, context);
++context.i;
break;
case '{':
result = this.parseMapping(value, context);
++context.i;
break;
default:
result = this.parseScalar(value, null, ['"', "'"], context);
}
if (this.PATTERN_TRAILING_COMMENTS.replace(value.slice(context.i), '') !== '') {
throw new ParseException('Unexpected characters near "' + value.slice(context.i) + '".');
}
return result;
};
Inline.dump = function (value, exceptionOnInvalidType, objectEncoder) {
var ref, result, type;
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectEncoder == null) {
objectEncoder = null;
}
if (value == null) {
return 'null';
}
type = typeof value;
if (type === 'object') {
if (value instanceof Date) {
return value.toISOString();
} else if (objectEncoder != null) {
result = objectEncoder(value);
if (typeof result === 'string' || (result != null)) {
return result;
}
}
return this.dumpObject(value);
}
if (type === 'boolean') {
return (value ? 'true' : 'false');
}
if (Utils.isDigits(value)) {
return (type === 'string' ? "'" + value + "'" : String(parseInt(value)));
}
if (Utils.isNumeric(value)) {
return (type === 'string' ? "'" + value + "'" : String(parseFloat(value)));
}
if (type === 'number') {
return (value === Infinity ? '.Inf' : (value === -Infinity ? '-.Inf' : (isNaN(value) ? '.NaN' : value)));
}
if (Escaper.requiresDoubleQuoting(value)) {
return Escaper.escapeWithDoubleQuotes(value);
}
if (Escaper.requiresSingleQuoting(value)) {
return Escaper.escapeWithSingleQuotes(value);
}
if ('' === value) {
return '""';
}
if (Utils.PATTERN_DATE.test(value)) {
return "'" + value + "'";
}
if ((ref = value.toLowerCase()) === 'null' || ref === '~' || ref === 'true' || ref === 'false') {
return "'" + value + "'";
}
return value;
};
Inline.dumpObject = function (value, exceptionOnInvalidType, objectSupport) {
var j, key, len1, output, val;
if (objectSupport == null) {
objectSupport = null;
}
if (value instanceof Array) {
output = [];
for (j = 0, len1 = value.length; j < len1; j++) {
val = value[j];
output.push(this.dump(val));
}
return '[' + output.join(', ') + ']';
} else {
output = [];
for (key in value) {
val = value[key];
output.push(this.dump(key) + ': ' + this.dump(val));
}
return '{' + output.join(', ') + '}';
}
};
Inline.parseScalar = function (scalar, delimiters, stringDelimiters, context, evaluate) {
var i, joinedDelimiters, match, output, pattern, ref, ref1, strpos, tmp;
if (delimiters == null) {
delimiters = null;
}
if (stringDelimiters == null) {
stringDelimiters = ['"', "'"];
}
if (context == null) {
context = null;
}
if (evaluate == null) {
evaluate = true;
}
if (context == null) {
context = {
exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
objectDecoder: this.settings.objectDecoder,
i: 0
};
}
i = context.i;
if (ref = scalar.charAt(i), indexOf.call(stringDelimiters, ref) >= 0) {
output = this.parseQuotedScalar(scalar, context);
i = context.i;
if (delimiters != null) {
tmp = Utils.ltrim(scalar.slice(i), ' ');
if (!(ref1 = tmp.charAt(0), indexOf.call(delimiters, ref1) >= 0)) {
throw new ParseException('Unexpected characters (' + scalar.slice(i) + ').');
}
}
} else {
if (!delimiters) {
output = scalar.slice(i);
i += output.length;
strpos = output.indexOf(' #');
if (strpos !== -1) {
output = Utils.rtrim(output.slice(0, strpos));
}
} else {
joinedDelimiters = delimiters.join('|');
pattern = this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters];
if (pattern == null) {
pattern = new Pattern('^(.+?)(' + joinedDelimiters + ')');
this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters] = pattern;
}
if (match = pattern.exec(scalar.slice(i))) {
output = match[1];
i += output.length;
} else {
throw new ParseException('Malformed inline YAML string (' + scalar + ').');
}
}
if (evaluate) {
output = this.evaluateScalar(output, context);
}
}
context.i = i;
return output;
};
Inline.parseQuotedScalar = function (scalar, context) {
var i, match, output;
i = context.i;
if (!(match = this.PATTERN_QUOTED_SCALAR.exec(scalar.slice(i)))) {
throw new ParseMore('Malformed inline YAML string (' + scalar.slice(i) + ').');
}
output = match[0].substr(1, match[0].length - 2);
if ('"' === scalar.charAt(i)) {
output = Unescaper.unescapeDoubleQuotedString(output);
} else {
output = Unescaper.unescapeSingleQuotedString(output);
}
i += match[0].length;
context.i = i;
return output;
};
Inline.parseSequence = function (sequence, context) {
var e, error, i, isQuoted, len, output, ref, value;
output = [];
len = sequence.length;
i = context.i;
i += 1;
while (i < len) {
context.i = i;
switch (sequence.charAt(i)) {
case '[':
output.push(this.parseSequence(sequence, context));
i = context.i;
break;
case '{':
output.push(this.parseMapping(sequence, context));
i = context.i;
break;
case ']':
return output;
case ',':
case ' ':
case "\n":
break;
default:
isQuoted = ((ref = sequence.charAt(i)) === '"' || ref === "'");
value = this.parseScalar(sequence, [',', ']'], ['"', "'"], context);
i = context.i;
if (!isQuoted && typeof value === 'string' && (value.indexOf(': ') !== -1 || value.indexOf(":\n") !== -1)) {
try {
value = this.parseMapping('{' + value + '}');
} catch (error) {
e = error;
}
}
output.push(value);
--i;
}
++i;
}
throw new ParseMore('Malformed inline YAML string ' + sequence);
};
Inline.parseMapping = function (mapping, context) {
var done, i, key, len, output, shouldContinueWhileLoop, value;
output = {};
len = mapping.length;
i = context.i;
i += 1;
shouldContinueWhileLoop = false;
while (i < len) {
context.i = i;
switch (mapping.charAt(i)) {
case ' ':
case ',':
case "\n":
++i;
context.i = i;
shouldContinueWhileLoop = true;
break;
case '}':
return output;
}
if (shouldContinueWhileLoop) {
shouldContinueWhileLoop = false;
continue;
}
key = this.parseScalar(mapping, [':', ' ', "\n"], ['"', "'"], context, false);
i = context.i;
done = false;
while (i < len) {
context.i = i;
switch (mapping.charAt(i)) {
case '[':
value = this.parseSequence(mapping, context);
i = context.i;
if (output[key] === void 0) {
output[key] = value;
}
done = true;
break;
case '{':
value = this.parseMapping(mapping, context);
i = context.i;
if (output[key] === void 0) {
output[key] = value;
}
done = true;
break;
case ':':
case ' ':
case "\n":
break;
default:
value = this.parseScalar(mapping, [',', '}'], ['"', "'"], context);
i = context.i;
if (output[key] === void 0) {
output[key] = value;
}
done = true;
--i;
}
++i;
if (done) {
break;
}
}
}
throw new ParseMore('Malformed inline YAML string ' + mapping);
};
Inline.evaluateScalar = function (scalar, context) {
var cast, date, exceptionOnInvalidType, firstChar, firstSpace, firstWord, objectDecoder, raw, scalarLower, subValue, trimmedScalar;
scalar = Utils.trim(scalar);
scalarLower = scalar.toLowerCase();
switch (scalarLower) {
case 'null':
case '':
case '~':
return null;
case 'true':
return true;
case 'false':
return false;
case '.inf':
return Infinity;
case '.nan':
return NaN;
case '-.inf':
return Infinity;
default:
firstChar = scalarLower.charAt(0);
switch (firstChar) {
case '!':
firstSpace = scalar.indexOf(' ');
if (firstSpace === -1) {
firstWord = scalarLower;
} else {
firstWord = scalarLower.slice(0, firstSpace);
}
switch (firstWord) {
case '!':
if (firstSpace !== -1) {
return parseInt(this.parseScalar(scalar.slice(2)));
}
return null;
case '!str':
return Utils.ltrim(scalar.slice(4));
case '!!str':
return Utils.ltrim(scalar.slice(5));
case '!!int':
return parseInt(this.parseScalar(scalar.slice(5)));
case '!!bool':
return Utils.parseBoolean(this.parseScalar(scalar.slice(6)), false);
case '!!float':
return parseFloat(this.parseScalar(scalar.slice(7)));
case '!!timestamp':
return Utils.stringToDate(Utils.ltrim(scalar.slice(11)));
default:
if (context == null) {
context = {
exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
objectDecoder: this.settings.objectDecoder,
i: 0
};
}
objectDecoder = context.objectDecoder, exceptionOnInvalidType = context.exceptionOnInvalidType;
if (objectDecoder) {
trimmedScalar = Utils.rtrim(scalar);
firstSpace = trimmedScalar.indexOf(' ');
if (firstSpace === -1) {
return objectDecoder(trimmedScalar, null);
} else {
subValue = Utils.ltrim(trimmedScalar.slice(firstSpace + 1));
if (!(subValue.length > 0)) {
subValue = null;
}
return objectDecoder(trimmedScalar.slice(0, firstSpace), subValue);
}
}
if (exceptionOnInvalidType) {
throw new ParseException('Custom object support when parsing a YAML file has been disabled.');
}
return null;
}
break;
case '0':
if ('0x' === scalar.slice(0, 2)) {
return Utils.hexDec(scalar);
} else if (Utils.isDigits(scalar)) {
return Utils.octDec(scalar);
} else if (Utils.isNumeric(scalar)) {
return parseFloat(scalar);
} else {
return scalar;
}
break;
case '+':
if (Utils.isDigits(scalar)) {
raw = scalar;
cast = parseInt(raw);
if (raw === String(cast)) {
return cast;
} else {
return raw;
}
} else if (Utils.isNumeric(scalar)) {
return parseFloat(scalar);
} else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
return parseFloat(scalar.replace(',', ''));
}
return scalar;
case '-':
if (Utils.isDigits(scalar.slice(1))) {
if ('0' === scalar.charAt(1)) {
return -Utils.octDec(scalar.slice(1));
} else {
raw = scalar.slice(1);
cast = parseInt(raw);
if (raw === String(cast)) {
return -cast;
} else {
return -raw;
}
}
} else if (Utils.isNumeric(scalar)) {
return parseFloat(scalar);
} else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
return parseFloat(scalar.replace(',', ''));
}
return scalar;
default:
if (date = Utils.stringToDate(scalar)) {
return date;
} else if (Utils.isNumeric(scalar)) {
return parseFloat(scalar);
} else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
return parseFloat(scalar.replace(',', ''));
}
return scalar;
}
}
};
return Inline;
})();
module.exports = Inline;
}, {
"./Escaper": 2,
"./Exception/DumpException": 3,
"./Exception/ParseException": 4,
"./Exception/ParseMore": 5,
"./Pattern": 8,
"./Unescaper": 9,
"./Utils": 10
}],
7: [function (require, module, exports) {
var Inline, ParseException, ParseMore, Parser, Pattern, Utils;
Inline = require('./Inline');
Pattern = require('./Pattern');
Utils = require('./Utils');
ParseException = require('./Exception/ParseException');
ParseMore = require('./Exception/ParseMore');
Parser = (function () {
Parser.prototype.PATTERN_FOLDED_SCALAR_ALL = new Pattern('^(?:(?<type>![^\\|>]*)\\s+)?(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');
Parser.prototype.PATTERN_FOLDED_SCALAR_END = new Pattern('(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');
Parser.prototype.PATTERN_SEQUENCE_ITEM = new Pattern('^\\-((?<leadspaces>\\s+)(?<value>.+?))?\\s*$');
Parser.prototype.PATTERN_ANCHOR_VALUE = new Pattern('^&(?<ref>[^ ]+) *(?<value>.*)');
Parser.prototype.PATTERN_COMPACT_NOTATION = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING + '|[^ \'"\\{\\[].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
Parser.prototype.PATTERN_MAPPING_ITEM = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING + '|[^ \'"\\[\\{].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
Parser.prototype.PATTERN_DECIMAL = new Pattern('\\d+');
Parser.prototype.PATTERN_INDENT_SPACES = new Pattern('^ +');
Parser.prototype.PATTERN_TRAILING_LINES = new Pattern('(\n*)$');
Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n', 'm');
Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+', 'm');
Parser.prototype.PATTERN_DOCUMENT_MARKER_START = new Pattern('^\\-\\-\\-.*?\n', 'm');
Parser.prototype.PATTERN_DOCUMENT_MARKER_END = new Pattern('^\\.\\.\\.\\s*$', 'm');
Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION = {};
Parser.prototype.CONTEXT_NONE = 0;
Parser.prototype.CONTEXT_SEQUENCE = 1;
Parser.prototype.CONTEXT_MAPPING = 2;
function Parser(offset) {
this.offset = offset != null ? offset : 0;
this.lines = [];
this.currentLineNb = -1;
this.currentLine = '';
this.refs = {};
}
Parser.prototype.parse = function (value, exceptionOnInvalidType, objectDecoder) {
var alias, allowOverwrite, block, c, context, data, e, error, error1, error2, first, i, indent, isRef, j, k, key, l, lastKey, len, len1, len2, len3, lineCount, m, matches, mergeNode, n, name, parsed, parsedItem, parser, ref, ref1, ref2, refName, refValue, val, values;
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectDecoder == null) {
objectDecoder = null;
}
this.currentLineNb = -1;
this.currentLine = '';
this.lines = this.cleanup(value).split("\n");
data = null;
context = this.CONTEXT_NONE;
allowOverwrite = false;
while (this.moveToNextLine()) {
if (this.isCurrentLineEmpty()) {
continue;
}
if ("\t" === this.currentLine[0]) {
throw new ParseException('A YAML file cannot contain tabs as indentation.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
isRef = mergeNode = false;
if (values = this.PATTERN_SEQUENCE_ITEM.exec(this.currentLine)) {
if (this.CONTEXT_MAPPING === context) {
throw new ParseException('You cannot define a sequence item when in a mapping');
}
context = this.CONTEXT_SEQUENCE;
if (data == null) {
data = [];
}
if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
isRef = matches.ref;
values.value = matches.value;
}
if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf('#') === 0) {
if (this.currentLineNb < this.lines.length - 1 && !this.isNextLineUnIndentedCollection()) {
c = this.getRealCurrentLineNb() + 1;
parser = new Parser(c);
parser.refs = this.refs;
data.push(parser.parse(this.getNextEmbedBlock(null, true), exceptionOnInvalidType, objectDecoder));
} else {
data.push(null);
}
} else {
if (((ref = values.leadspaces) != null ? ref.length : void 0) && (matches = this.PATTERN_COMPACT_NOTATION.exec(values.value))) {
c = this.getRealCurrentLineNb();
parser = new Parser(c);
parser.refs = this.refs;
block = values.value;
indent = this.getCurrentLineIndentation();
if (this.isNextLineIndented(false)) {
block += "\n" + this.getNextEmbedBlock(indent + values.leadspaces.length + 1, true);
}
data.push(parser.parse(block, exceptionOnInvalidType, objectDecoder));
} else {
data.push(this.parseValue(values.value, exceptionOnInvalidType, objectDecoder));
}
}
} else if ((values = this.PATTERN_MAPPING_ITEM.exec(this.currentLine)) && values.key.indexOf(' #') === -1) {
if (this.CONTEXT_SEQUENCE === context) {
throw new ParseException('You cannot define a mapping item when in a sequence');
}
context = this.CONTEXT_MAPPING;
if (data == null) {
data = {};
}
Inline.configure(exceptionOnInvalidType, objectDecoder);
try {
key = Inline.parseScalar(values.key);
} catch (error) {
e = error;
e.parsedLine = this.getRealCurrentLineNb() + 1;
e.snippet = this.currentLine;
throw e;
}
if ('<<' === key) {
mergeNode = true;
allowOverwrite = true;
if (((ref1 = values.value) != null ? ref1.indexOf('*') : void 0) === 0) {
refName = values.value.slice(1);
if (this.refs[refName] == null) {
throw new ParseException('Reference "' + refName + '" does not exist.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
refValue = this.refs[refName];
if (typeof refValue !== 'object') {
throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
if (refValue instanceof Array) {
for (i = j = 0, len = refValue.length; j < len; i = ++j) {
value = refValue[i];
if (data[name = String(i)] == null) {
data[name] = value;
}
}
} else {
for (key in refValue) {
value = refValue[key];
if (data[key] == null) {
data[key] = value;
}
}
}
} else {
if ((values.value != null) && values.value !== '') {
value = values.value;
} else {
value = this.getNextEmbedBlock();
}
c = this.getRealCurrentLineNb() + 1;
parser = new Parser(c);
parser.refs = this.refs;
parsed = parser.parse(value, exceptionOnInvalidType);
if (typeof parsed !== 'object') {
throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
if (parsed instanceof Array) {
for (l = 0, len1 = parsed.length; l < len1; l++) {
parsedItem = parsed[l];
if (typeof parsedItem !== 'object') {
throw new ParseException('Merge items must be objects.', this.getRealCurrentLineNb() + 1, parsedItem);
}
if (parsedItem instanceof Array) {
for (i = m = 0, len2 = parsedItem.length; m < len2; i = ++m) {
value = parsedItem[i];
k = String(i);
if (!data.hasOwnProperty(k)) {
data[k] = value;
}
}
} else {
for (key in parsedItem) {
value = parsedItem[key];
if (!data.hasOwnProperty(key)) {
data[key] = value;
}
}
}
}
} else {
for (key in parsed) {
value = parsed[key];
if (!data.hasOwnProperty(key)) {
data[key] = value;
}
}
}
}
} else if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
isRef = matches.ref;
values.value = matches.value;
}
if (mergeNode) {
} else if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf('#') === 0) {
if (!(this.isNextLineIndented()) && !(this.isNextLineUnIndentedCollection())) {
if (allowOverwrite || data[key] === void 0) {
data[key] = null;
}
} else {
c = this.getRealCurrentLineNb() + 1;
parser = new Parser(c);
parser.refs = this.refs;
val = parser.parse(this.getNextEmbedBlock(), exceptionOnInvalidType, objectDecoder);
if (allowOverwrite || data[key] === void 0) {
data[key] = val;
}
}
} else {
val = this.parseValue(values.value, exceptionOnInvalidType, objectDecoder);
if (allowOverwrite || data[key] === void 0) {
data[key] = val;
}
}
} else {
lineCount = this.lines.length;
if (1 === lineCount || (2 === lineCount && Utils.isEmpty(this.lines[1]))) {
try {
value = Inline.parse(this.lines[0], exceptionOnInvalidType, objectDecoder);
} catch (error1) {
e = error1;
e.parsedLine = this.getRealCurrentLineNb() + 1;
e.snippet = this.currentLine;
throw e;
}
if (typeof value === 'object') {
if (value instanceof Array) {
first = value[0];
} else {
for (key in value) {
first = value[key];
break;
}
}
if (typeof first === 'string' && first.indexOf('*') === 0) {
data = [];
for (n = 0, len3 = value.length; n < len3; n++) {
alias = value[n];
data.push(this.refs[alias.slice(1)]);
}
value = data;
}
}
return value;
} else if ((ref2 = Utils.ltrim(value).charAt(0)) === '[' || ref2 === '{') {
try {
return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
} catch (error2) {
e = error2;
e.parsedLine = this.getRealCurrentLineNb() + 1;
e.snippet = this.currentLine;
throw e;
}
}
throw new ParseException('Unable to parse.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
if (isRef) {
if (data instanceof Array) {
this.refs[isRef] = data[data.length - 1];
} else {
lastKey = null;
for (key in data) {
lastKey = key;
}
this.refs[isRef] = data[lastKey];
}
}
}
if (Utils.isEmpty(data)) {
return null;
} else {
return data;
}
};
Parser.prototype.getRealCurrentLineNb = function () {
return this.currentLineNb + this.offset;
};
Parser.prototype.getCurrentLineIndentation = function () {
return this.currentLine.length - Utils.ltrim(this.currentLine, ' ').length;
};
Parser.prototype.getNextEmbedBlock = function (indentation, includeUnindentedCollection) {
var data, indent, isItUnindentedCollection, newIndent, removeComments, removeCommentsPattern, unindentedEmbedBlock;
if (indentation == null) {
indentation = null;
}
if (includeUnindentedCollection == null) {
includeUnindentedCollection = false;
}
this.moveToNextLine();
if (indentation == null) {
newIndent = this.getCurrentLineIndentation();
unindentedEmbedBlock = this.isStringUnIndentedCollectionItem(this.currentLine);
if (!(this.isCurrentLineEmpty()) && 0 === newIndent && !unindentedEmbedBlock) {
throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
} else {
newIndent = indentation;
}
data = [this.currentLine.slice(newIndent)];
if (!includeUnindentedCollection) {
isItUnindentedCollection = this.isStringUnIndentedCollectionItem(this.currentLine);
}
removeCommentsPattern = this.PATTERN_FOLDED_SCALAR_END;
removeComments = !removeCommentsPattern.test(this.currentLine);
while (this.moveToNextLine()) {
indent = this.getCurrentLineIndentation();
if (indent === newIndent) {
removeComments = !removeCommentsPattern.test(this.currentLine);
}
if (removeComments && this.isCurrentLineComment()) {
continue;
}
if (this.isCurrentLineBlank()) {
data.push(this.currentLine.slice(newIndent));
continue;
}
if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent === newIndent) {
this.moveToPreviousLine();
break;
}
if (indent >= newIndent) {
data.push(this.currentLine.slice(newIndent));
} else if (Utils.ltrim(this.currentLine).charAt(0) === '#') {
} else if (0 === indent) {
this.moveToPreviousLine();
break;
} else {
throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
}
}
return data.join("\n");
};
Parser.prototype.moveToNextLine = function () {
if (this.currentLineNb >= this.lines.length - 1) {
return false;
}
this.currentLine = this.lines[++this.currentLineNb];
return true;
};
Parser.prototype.moveToPreviousLine = function () {
this.currentLine = this.lines[--this.currentLineNb];
};
Parser.prototype.parseValue = function (value, exceptionOnInvalidType, objectDecoder) {
var e, error, foldedIndent, matches, modifiers, pos, ref, ref1, val;
if (0 === value.indexOf('*')) {
pos = value.indexOf('#');
if (pos !== -1) {
value = value.substr(1, pos - 2);
} else {
value = value.slice(1);
}
if (this.refs[value] === void 0) {
throw new ParseException('Reference "' + value + '" does not exist.', this.currentLine);
}
return this.refs[value];
}
if (matches = this.PATTERN_FOLDED_SCALAR_ALL.exec(value)) {
modifiers = (ref = matches.modifiers) != null ? ref : '';
foldedIndent = Math.abs(parseInt(modifiers));
if (isNaN(foldedIndent)) {
foldedIndent = 0;
}
val = this.parseFoldedScalar(matches.separator, this.PATTERN_DECIMAL.replace(modifiers, ''), foldedIndent);
if (matches.type != null) {
Inline.configure(exceptionOnInvalidType, objectDecoder);
return Inline.parseScalar(matches.type + ' ' + val);
} else {
return val;
}
}
if ((ref1 = value.charAt(0)) === '[' || ref1 === '{' || ref1 === '"' || ref1 === "'") {
while (true) {
try {
return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
} catch (error) {
e = error;
if (e instanceof ParseMore && this.moveToNextLine()) {
value += "\n" + Utils.trim(this.currentLine, ' ');
} else {
e.parsedLine = this.getRealCurrentLineNb() + 1;
e.snippet = this.currentLine;
throw e;
}
}
}
} else {
if (this.isNextLineIndented()) {
value += "\n" + this.getNextEmbedBlock();
}
return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
}
};
Parser.prototype.parseFoldedScalar = function (separator, indicator, indentation) {
var isCurrentLineBlank, j, len, line, matches, newText, notEOF, pattern, ref, text;
if (indicator == null) {
indicator = '';
}
if (indentation == null) {
indentation = 0;
}
notEOF = this.moveToNextLine();
if (!notEOF) {
return '';
}
isCurrentLineBlank = this.isCurrentLineBlank();
text = '';
while (notEOF && isCurrentLineBlank) {
if (notEOF = this.moveToNextLine()) {
text += "\n";
isCurrentLineBlank = this.isCurrentLineBlank();
}
}
if (0 === indentation) {
if (matches = this.PATTERN_INDENT_SPACES.exec(this.currentLine)) {
indentation = matches[0].length;
}
}
if (indentation > 0) {
pattern = this.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation];
if (pattern == null) {
pattern = new Pattern('^ {' + indentation + '}(.*)$');
Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation] = pattern;
}
while (notEOF && (isCurrentLineBlank || (matches = pattern.exec(this.currentLine)))) {
if (isCurrentLineBlank) {
text += this.currentLine.slice(indentation);
} else {
text += matches[1];
}
if (notEOF = this.moveToNextLine()) {
text += "\n";
isCurrentLineBlank = this.isCurrentLineBlank();
}
}
} else if (notEOF) {
text += "\n";
}
if (notEOF) {
this.moveToPreviousLine();
}
if ('>' === separator) {
newText = '';
ref = text.split("\n");
for (j = 0, len = ref.length; j < len; j++) {
line = ref[j];
if (line.length === 0 || line.charAt(0) === ' ') {
newText = Utils.rtrim(newText, ' ') + line + "\n";
} else {
newText += line + ' ';
}
}
text = newText;
}
if ('+' !== indicator) {
text = Utils.rtrim(text);
}
if ('' === indicator) {
text = this.PATTERN_TRAILING_LINES.replace(text, "\n");
} else if ('-' === indicator) {
text = this.PATTERN_TRAILING_LINES.replace(text, '');
}
return text;
};
Parser.prototype.isNextLineIndented = function (ignoreComments) {
var EOF, currentIndentation, ret;
if (ignoreComments == null) {
ignoreComments = true;
}
currentIndentation = this.getCurrentLineIndentation();
EOF = !this.moveToNextLine();
if (ignoreComments) {
while (!EOF && this.isCurrentLineEmpty()) {
EOF = !this.moveToNextLine();
}
} else {
while (!EOF && this.isCurrentLineBlank()) {
EOF = !this.moveToNextLine();
}
}
if (EOF) {
return false;
}
ret = false;
if (this.getCurrentLineIndentation() > currentIndentation) {
ret = true;
}
this.moveToPreviousLine();
return ret;
};
Parser.prototype.isCurrentLineEmpty = function () {
var trimmedLine;
trimmedLine = Utils.trim(this.currentLine, ' ');
return trimmedLine.length === 0 || trimmedLine.charAt(0) === '#';
};
Parser.prototype.isCurrentLineBlank = function () {
return '' === Utils.trim(this.currentLine, ' ');
};
Parser.prototype.isCurrentLineComment = function () {
var ltrimmedLine;
ltrimmedLine = Utils.ltrim(this.currentLine, ' ');
return ltrimmedLine.charAt(0) === '#';
};
Parser.prototype.cleanup = function (value) {
var count, i, indent, j, l, len, len1, line, lines, ref, ref1, ref2, smallestIndent, trimmedValue;
if (value.indexOf("\r") !== -1) {
value = value.split("\r\n").join("\n").split("\r").join("\n");
}
count = 0;
ref = this.PATTERN_YAML_HEADER.replaceAll(value, ''), value = ref[0], count = ref[1];
this.offset += count;
ref1 = this.PATTERN_LEADING_COMMENTS.replaceAll(value, '', 1), trimmedValue = ref1[0], count = ref1[1];
if (count === 1) {
this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
value = trimmedValue;
}
ref2 = this.PATTERN_DOCUMENT_MARKER_START.replaceAll(value, '', 1), trimmedValue = ref2[0], count = ref2[1];
if (count === 1) {
this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
value = trimmedValue;
value = this.PATTERN_DOCUMENT_MARKER_END.replace(value, '');
}
lines = value.split("\n");
smallestIndent = -1;
for (j = 0, len = lines.length; j < len; j++) {
line = lines[j];
if (Utils.trim(line, ' ').length === 0) {
continue;
}
indent = line.length - Utils.ltrim(line).length;
if (smallestIndent === -1 || indent < smallestIndent) {
smallestIndent = indent;
}
}
if (smallestIndent > 0) {
for (i = l = 0, len1 = lines.length; l < len1; i = ++l) {
line = lines[i];
lines[i] = line.slice(smallestIndent);
}
value = lines.join("\n");
}
return value;
};
Parser.prototype.isNextLineUnIndentedCollection = function (currentIndentation) {
var notEOF, ret;
if (currentIndentation == null) {
currentIndentation = null;
}
if (currentIndentation == null) {
currentIndentation = this.getCurrentLineIndentation();
}
notEOF = this.moveToNextLine();
while (notEOF && this.isCurrentLineEmpty()) {
notEOF = this.moveToNextLine();
}
if (false === notEOF) {
return false;
}
ret = false;
if (this.getCurrentLineIndentation() === currentIndentation && this.isStringUnIndentedCollectionItem(this.currentLine)) {
ret = true;
}
this.moveToPreviousLine();
return ret;
};
Parser.prototype.isStringUnIndentedCollectionItem = function () {
return this.currentLine === '-' || this.currentLine.slice(0, 2) === '- ';
};
return Parser;
})();
module.exports = Parser;
}, {
"./Exception/ParseException": 4,
"./Exception/ParseMore": 5,
"./Inline": 6,
"./Pattern": 8,
"./Utils": 10
}],
8: [function (require, module, exports) {
var Pattern;
Pattern = (function () {
Pattern.prototype.regex = null;
Pattern.prototype.rawRegex = null;
Pattern.prototype.cleanedRegex = null;
Pattern.prototype.mapping = null;
function Pattern(rawRegex, modifiers) {
var _char, capturingBracketNumber, cleanedRegex, i, len, mapping, name, part, subChar;
if (modifiers == null) {
modifiers = '';
}
cleanedRegex = '';
len = rawRegex.length;
mapping = null;
capturingBracketNumber = 0;
i = 0;
while (i < len) {
_char = rawRegex.charAt(i);
if (_char === '\\') {
cleanedRegex += rawRegex.slice(i, +(i + 1) + 1 || 9e9);
i++;
} else if (_char === '(') {
if (i < len - 2) {
part = rawRegex.slice(i, +(i + 2) + 1 || 9e9);
if (part === '(?:') {
i += 2;
cleanedRegex += part;
} else if (part === '(?<') {
capturingBracketNumber++;
i += 2;
name = '';
while (i + 1 < len) {
subChar = rawRegex.charAt(i + 1);
if (subChar === '>') {
cleanedRegex += '(';
i++;
if (name.length > 0) {
if (mapping == null) {
mapping = {};
}
mapping[name] = capturingBracketNumber;
}
break;
} else {
name += subChar;
}
i++;
}
} else {
cleanedRegex += _char;
capturingBracketNumber++;
}
} else {
cleanedRegex += _char;
}
} else {
cleanedRegex += _char;
}
i++;
}
this.rawRegex = rawRegex;
this.cleanedRegex = cleanedRegex;
this.regex = new RegExp(this.cleanedRegex, 'g' + modifiers.replace('g', ''));
this.mapping = mapping;
}
Pattern.prototype.exec = function (str) {
var index, matches, name, ref;
this.regex.lastIndex = 0;
matches = this.regex.exec(str);
if (matches == null) {
return null;
}
if (this.mapping != null) {
ref = this.mapping;
for (name in ref) {
index = ref[name];
matches[name] = matches[index];
}
}
return matches;
};
Pattern.prototype.test = function (str) {
this.regex.lastIndex = 0;
return this.regex.test(str);
};
Pattern.prototype.replace = function (str, replacement) {
this.regex.lastIndex = 0;
return str.replace(this.regex, replacement);
};
Pattern.prototype.replaceAll = function (str, replacement, limit) {
var count;
if (limit == null) {
limit = 0;
}
this.regex.lastIndex = 0;
count = 0;
while (this.regex.test(str) && (limit === 0 || count < limit)) {
this.regex.lastIndex = 0;
str = str.replace(this.regex, replacement);
count++;
}
return [str, count];
};
return Pattern;
})();
module.exports = Pattern;
}, {}],
9: [function (require, module, exports) {
var Pattern, Unescaper, Utils;
Utils = require('./Utils');
Pattern = require('./Pattern');
Unescaper = (function () {
function Unescaper() { }
Unescaper.PATTERN_ESCAPED_CHARACTER = new Pattern('\\\\([0abt\tnvfre "\\/\\\\N_LP]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})');
Unescaper.unescapeSingleQuotedString = function (value) {
return value.replace(/\'\'/g, '\'');
};
Unescaper.unescapeDoubleQuotedString = function (value) {
if (this._unescapeCallback == null) {
this._unescapeCallback = (function (_this) {
return function (str) {
return _this.unescapeCharacter(str);
};
})(this);
}
return this.PATTERN_ESCAPED_CHARACTER.replace(value, this._unescapeCallback);
};
Unescaper.unescapeCharacter = function (value) {
var ch;
ch = String.fromCharCode;
switch (value.charAt(1)) {
case '0':
return ch(0);
case 'a':
return ch(7);
case 'b':
return ch(8);
case 't':
return "\t";
case "\t":
return "\t";
case 'n':
return "\n";
case 'v':
return ch(11);
case 'f':
return ch(12);
case 'r':
return ch(13);
case 'e':
return ch(27);
case ' ':
return ' ';
case '"':
return '"';
case '/':
return '/';
case '\\':
return '\\';
case 'N':
return ch(0x0085);
case '_':
return ch(0x00A0);
case 'L':
return ch(0x2028);
case 'P':
return ch(0x2029);
case 'x':
return Utils.utf8chr(Utils.hexDec(value.substr(2, 2)));
case 'u':
return Utils.utf8chr(Utils.hexDec(value.substr(2, 4)));
case 'U':
return Utils.utf8chr(Utils.hexDec(value.substr(2, 8)));
default:
return '';
}
};
return Unescaper;
})();
module.exports = Unescaper;
}, {
"./Pattern": 8,
"./Utils": 10
}],
10: [function (require, module, exports) {
var Pattern, Utils,
hasProp = {}.hasOwnProperty;
Pattern = require('./Pattern');
Utils = (function () {
function Utils() { }
Utils.REGEX_LEFT_TRIM_BY_CHAR = {};
Utils.REGEX_RIGHT_TRIM_BY_CHAR = {};
Utils.REGEX_SPACES = /\s+/g;
Utils.REGEX_DIGITS = /^\d+$/;
Utils.REGEX_OCTAL = /[^0-7]/gi;
Utils.REGEX_HEXADECIMAL = /[^a-f0-9]/gi;
Utils.PATTERN_DATE = new Pattern('^' + '(?<year>[0-9][0-9][0-9][0-9])' + '-(?<month>[0-9][0-9]?)' + '-(?<day>[0-9][0-9]?)' + '(?:(?:[Tt]|[ \t]+)' + '(?<hour>[0-9][0-9]?)' + ':(?<minute>[0-9][0-9])' + ':(?<second>[0-9][0-9])' + '(?:\.(?<fraction>[0-9]*))?' + '(?:[ \t]*(?<tz>Z|(?<tz_sign>[-+])(?<tz_hour>[0-9][0-9]?)' + '(?::(?<tz_minute>[0-9][0-9]))?))?)?' + '$', 'i');
Utils.LOCAL_TIMEZONE_OFFSET = new Date().getTimezoneOffset() * 60 * 1000;
Utils.trim = function (str, _char) {
var regexLeft, regexRight;
if (_char == null) {
_char = '\\s';
}
regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
if (regexLeft == null) {
this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
}
regexLeft.lastIndex = 0;
regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
if (regexRight == null) {
this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
}
regexRight.lastIndex = 0;
return str.replace(regexLeft, '').replace(regexRight, '');
};
Utils.ltrim = function (str, _char) {
var regexLeft;
if (_char == null) {
_char = '\\s';
}
regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
if (regexLeft == null) {
this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
}
regexLeft.lastIndex = 0;
return str.replace(regexLeft, '');
};
Utils.rtrim = function (str, _char) {
var regexRight;
if (_char == null) {
_char = '\\s';
}
regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
if (regexRight == null) {
this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
}
regexRight.lastIndex = 0;
return str.replace(regexRight, '');
};
Utils.isEmpty = function (value) {
return !value || value === '' || value === '0' || (value instanceof Array && value.length === 0) || this.isEmptyObject(value);
};
Utils.isEmptyObject = function (value) {
var k;
return value instanceof Object && ((function () {
var results;
results = [];
for (k in value) {
if (!hasProp.call(value, k)) continue;
results.push(k);
}
return results;
})()).length === 0;
};
Utils.subStrCount = function (string, subString, start, length) {
var c, i, j, len, ref, sublen;
c = 0;
string = '' + string;
subString = '' + subString;
if (start != null) {
string = string.slice(start);
}
if (length != null) {
string = string.slice(0, length);
}
len = string.length;
sublen = subString.length;
for (i = j = 0, ref = len; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
if (subString === string.slice(i, sublen)) {
c++;
i += sublen - 1;
}
}
return c;
};
Utils.isDigits = function (input) {
this.REGEX_DIGITS.lastIndex = 0;
return this.REGEX_DIGITS.test(input);
};
Utils.octDec = function (input) {
this.REGEX_OCTAL.lastIndex = 0;
return parseInt((input + '').replace(this.REGEX_OCTAL, ''), 8);
};
Utils.hexDec = function (input) {
this.REGEX_HEXADECIMAL.lastIndex = 0;
input = this.trim(input);
if ((input + '').slice(0, 2) === '0x') {
input = (input + '').slice(2);
}
return parseInt((input + '').replace(this.REGEX_HEXADECIMAL, ''), 16);
};
Utils.utf8chr = function (c) {
var ch;
ch = String.fromCharCode;
if (0x80 > (c %= 0x200000)) {
return ch(c);
}
if (0x800 > c) {
return ch(0xC0 | c >> 6) + ch(0x80 | c & 0x3F);
}
if (0x10000 > c) {
return ch(0xE0 | c >> 12) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
}
return ch(0xF0 | c >> 18) + ch(0x80 | c >> 12 & 0x3F) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
};
Utils.parseBoolean = function (input, strict) {
var lowerInput;
if (strict == null) {
strict = true;
}
if (typeof input === 'string') {
lowerInput = input.toLowerCase();
if (!strict) {
if (lowerInput === 'no') {
return false;
}
}
if (lowerInput === '0') {
return false;
}
if (lowerInput === 'false') {
return false;
}
if (lowerInput === '') {
return false;
}
return true;
}
return !!input;
};
Utils.isNumeric = function (input) {
this.REGEX_SPACES.lastIndex = 0;
return typeof input === 'number' || typeof input === 'string' && !isNaN(input) && input.replace(this.REGEX_SPACES, '') !== '';
};
Utils.stringToDate = function (str) {
var date, day, fraction, hour, info, minute, month, second, tz_hour, tz_minute, tz_offset, year;
if (!(str != null ? str.length : void 0)) {
return null;
}
info = this.PATTERN_DATE.exec(str);
if (!info) {
return null;
}
year = parseInt(info.year, 10);
month = parseInt(info.month, 10) - 1;
day = parseInt(info.day, 10);
if (info.hour == null) {
date = new Date(Date.UTC(year, month, day));
return date;
}
hour = parseInt(info.hour, 10);
minute = parseInt(info.minute, 10);
second = parseInt(info.second, 10);
if (info.fraction != null) {
fraction = info.fraction.slice(0, 3);
while (fraction.length < 3) {
fraction += '0';
}
fraction = parseInt(fraction, 10);
} else {
fraction = 0;
}
if (info.tz != null) {
tz_hour = parseInt(info.tz_hour, 10);
if (info.tz_minute != null) {
tz_minute = parseInt(info.tz_minute, 10);
} else {
tz_minute = 0;
}
tz_offset = (tz_hour * 60 + tz_minute) * 60000;
if ('-' === info.tz_sign) {
tz_offset *= -1;
}
}
date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
if (tz_offset) {
date.setTime(date.getTime() - tz_offset);
}
return date;
};
Utils.strRepeat = function (str, number) {
var i, res;
res = '';
i = 0;
while (i < number) {
res += str;
i++;
}
return res;
};
Utils.getStringFromFile = function (path, callback) {
var data, fs, j, len1, name, ref, req, xhr;
if (callback == null) {
callback = null;
}
xhr = null;
if (typeof window !== "undefined" && window !== null) {
if (window.XMLHttpRequest) {
xhr = new XMLHttpRequest();
} else if (window.ActiveXObject) {
ref = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"];
for (j = 0, len1 = ref.length; j < len1; j++) {
name = ref[j];
try {
xhr = new ActiveXObject(name);
} catch (undefined) { }
}
}
}
if (xhr != null) {
if (callback != null) {
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
if (xhr.status === 200 || xhr.status === 0) {
return callback(xhr.responseText);
} else {
return callback(null);
}
}
};
xhr.open('GET', path, true);
return xhr.send(null);
} else {
xhr.open('GET', path, false);
xhr.send(null);
if (xhr.status === 200 || xhr.status === 0) {
return xhr.responseText;
}
return null;
}
} else {
req = require;
fs = req('fs');
if (callback != null) {
return fs.readFile(path, function (err, data) {
if (err) {
return callback(null);
} else {
return callback(String(data));
}
});
} else {
data = fs.readFileSync(path);
if (data != null) {
return String(data);
}
return null;
}
}
};
return Utils;
})();
module.exports = Utils;
}, {
"./Pattern": 8
}],
11: [function (require, module, exports) {
var Dumper, Parser, Utils, Yaml;
Parser = require('./Parser');
Dumper = require('./Dumper');
Utils = require('./Utils');
Yaml = (function () {
function Yaml() { }
Yaml.parse = function (input, exceptionOnInvalidType, objectDecoder) {
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectDecoder == null) {
objectDecoder = null;
}
return new Parser().parse(input, exceptionOnInvalidType, objectDecoder);
};
Yaml.parseFile = function (path, callback, exceptionOnInvalidType, objectDecoder) {
var input;
if (callback == null) {
callback = null;
}
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectDecoder == null) {
objectDecoder = null;
}
if (callback != null) {
return Utils.getStringFromFile(path, (function (_this) {
return function (input) {
var result;
result = null;
if (input != null) {
result = _this.parse(input, exceptionOnInvalidType, objectDecoder);
}
callback(result);
};
})(this));
} else {
input = Utils.getStringFromFile(path);
if (input != null) {
return this.parse(input, exceptionOnInvalidType, objectDecoder);
}
return null;
}
};
Yaml.dump = function (input, inline, indent, exceptionOnInvalidType, objectEncoder) {
var yaml;
if (inline == null) {
inline = 2;
}
if (indent == null) {
indent = 4;
}
if (exceptionOnInvalidType == null) {
exceptionOnInvalidType = false;
}
if (objectEncoder == null) {
objectEncoder = null;
}
yaml = new Dumper();
yaml.indentation = indent;
return yaml.dump(input, inline, 0, exceptionOnInvalidType, objectEncoder);
};
Yaml.stringify = function (input, inline, indent, exceptionOnInvalidType, objectEncoder) {
return this.dump(input, inline, indent, exceptionOnInvalidType, objectEncoder);
};
Yaml.load = function (path, callback, exceptionOnInvalidType, objectDecoder) {
return this.parseFile(path, callback, exceptionOnInvalidType, objectDecoder);
};
return Yaml;
})();
if (typeof window !== "undefined" && window !== null) {
window.YAML = Yaml;
}
if (typeof window === "undefined" || window === null) {
this.YAML = Yaml;
}
module.exports = Yaml;
}, {
"./Dumper": 1,
"./Parser": 7,
"./Utils": 10
}]
}, {}, [11]);
Merci @bsfaxi ! Tu saurais nous guider dans chaque étape pour l’intégrer stp ?
Ca ne te tente pas d’en faire un custom component ? 
Hello,
Je ne pense pas pouvoir aller jusqu’à créer un custom component. Mes compétences de dev sont assez restreintes, plutôt au niveau débrouillard.
La procédure est assez simple :
1 - déployer le fichier ainsi que le fichier config dans le répertoire www.
Perso, j’ai créé un sous-répertoire portant le nom de ce fichier. J’ai aussi compressé les 2 fichiers en « .gz ».
2 - le déclarer en tant que ressource JS
- url: /local/resources/custom-sidebar/custom-sidebar.js
type: module
3 - redémarrer HA