xsl: include et xsl: param sur Google Chrome, avec le plugin de transformation jQuery

J’ai essayé d’utiliser XSL avec Google Chrome, mais sans succès.
J’ai lu que Chrome avait quelques bugs avec XSLT, et l’un d’eux était qu’il ne supportait pas xsl: include. Le bogue peut être vérifié ici: http://code.google.com/p/chromium/issues/detail?id=8441 .
Après quelques recherches, j’ai trouvé une nouvelle version du plugin transform de Daer System, qui permet à xsl: include de fonctionner sur Chrome.

Le plug-in jQuery Transform est disponible à l’ adresse http://plugins.jquery.com/project/Transform.

Maintenant, mon problème est:
J’utilise une inclusion par défaut dans certains modèles xsl, et cette inclusion utilise un paramètre qui est transmis au niveau supérieur.

C’est donc comme si j’avais le modèle top.xsl qui déclare un [xsl: param name = “param” /], et j’utilise ce paramètre avec le include.xsl , appelé par le premier avec [xsl: include href = “included.xsl”]. Cela fonctionne à la fois sur Firefox et Internet Explorer, mais pas sur Chrome. J’ai vu une question ici sur stackoverflow où un gars réécrit la fonction de correction de kit Web à partir du plugin, mais cela ne fonctionne pas avec xsl: param de cette façon.

Est-ce que quelqu’un sait comment utiliser [xsl: param] comme ceci dans Google Chrome?

Votre problème ici est que Google Chrome (= Chromium) ne prend pas en charge xsl:include

L’absence de cette fonctionnalité est bien notée dans le projet Chromium, comme indiqué dans “Problème 8441: Le processeur XSLTProcessor dans JS n’autorise pas l’utilisation de xsl: include pour http” . Il semble que le problème soit dû à un problème d’architecture dans WebKit (le moteur de rendu utilisé dans Chrome). Étant donné que ce problème provient de WebKit, le bogue est marqué comme WontFix – le correctif sera fourni (espérons-le) à l’avenir, car le problème d’origine dans le WebKit est en cours de résolution.

Je vois trois solutions possibles pour résoudre ce problème:

  1. Attendez que WebKit / Chrome reçoive un correctif qui résout ce problème (cela prend potentiellement beaucoup de temps …)
  2. Créez / trouvez un hack qui contourne ce problème, par exemple en émulant xsl:include pour Chrome / Webkit (nécessite potentiellement beaucoup de travail / un hack)
  3. Essayez de trouver un moyen d’écrire votre logiciel de manière à ne pas nécessiter cette fonctionnalité XSL spécifique (sinon, exécutez la transformation XSL du côté serveur).

Ma recommandation: évitez d’utiliser xsl: include avec xsl: param côté client, à moins que vous ne souhaitiez abandonner la compatibilité entre navigateurs.

Vieux sujet que je connais, mais vérifié ici pour voir si le problème a été résolu.

J’ai testé à nouveau et il a, au moins dans la version 47 de Chrome. Enfin, vous pouvez utiliser xsl: include.

C’est un problème, mais vous pouvez également contourner ce problème en utilisant une cale côté client qui précharge tout fichier xsl: import / xsl: includes dans le navigateur.

Ce qui suit est TypeScript (JavaScript essentiellement statique typé compilant JavaScript) et contient quelques références à des interfaces que..uh, je ne me suis pas soucié de le supprimer, mais il semble fonctionner dans Chrome (pas sûr des autres navigateurs) et devrait l’être assez pour que quelqu’un commence à trouver une solution.

 module DD.Render.DOM.XSLT { export class StandardXSLTDOMTransformerFactory implements IXSLTDOMTransformerFactory { constructor(private _domParser:DOMParser, private _document:Document) { } createTransformerFromPath(xslPath: ssortingng, xmlTransformer: ISsortingngTransformer, onSuccess: (transformer: IParameterizedDOMTransformer) => void, onFailure: (e: any) => void): void { DD.Util.readXML( xslPath, (node: Node) => { // look up any xsl:import or xsl:includes and pull those in too! var onIncludesPreloaded = () => { console.log(node); var transformer = this.createTransformerFromNode(node, xmlTransformer); onSuccess(transformer); }; this.rewriteIncludes(xslPath, node, {}, onIncludesPreloaded, onFailure); }, function (e: any) { onFailure(e); } ); } rewriteIncludes(path:ssortingng, node: Node, imported: { [_: ssortingng]: boolean }, onRewritten:()=>void, onFailure:(e:any)=>void): void { var result; var element = node; var importNodes = element.querySelectorAll("import,include"); if (importNodes.length == 0) { onRewritten(); result = false; } else { var rewrittenNodes = 0; // load imports for (var i = 0; i < importNodes.length; i++) { var importElement = importNodes.item(i); var href = importElement.getAtsortingbute("href"); // TODO work out relative path var relativePath = DD.Util.appendRelativePath(path, href); console.log("importing " + href +" + "+path+" -> "+relativePath); if (!imported[relativePath]) { var e = importElement; imported[relativePath] = true; DD.Util.readXML(relativePath, (importedStylesheet: Node) => { this.rewriteIncludes(relativePath, importedStylesheet, imported, function () { // replace the import with this node (minus stylesheet container) for (var j = 0; j < importedStylesheet.firstChild.childNodes.length; j++) { var templateNode = importedStylesheet.firstChild.childNodes.item(j); if (templateNode.nodeName.indexOf("template") >= 0) { e.parentNode.insertBefore(templateNode, e); } } e.parentNode.removeChild(e); rewrittenNodes++; if (rewrittenNodes == importNodes.length) { if (onRewritten) { onRewritten(); } } }, onFailure); }, onFailure); } else { importElement.parentNode.removeChild(importElement); } } result = true; } return result; } createTransformerFromNode(xsl: Node, xmlTransformer: ISsortingngTransformer): IParameterizedDOMTransformer { var nodeTransformer = new DOMParserDOMTransformer(this._domParser, xmlTransformer); var xsltProcessor = new XSLTProcessor(); xsltProcessor.importStylesheet(xsl); return new StandardXSLTDOMTransformer(xsltProcessor, nodeTransformer, this._document); } } } module DD.Util { export function readXML(path: ssortingng, onSuccess: (node: Node) => void, onFailure: (e: any) => void) { var xhr = new XMLHttpRequest(); xhr.onload = function () { onSuccess(xhr.responseXML); }; xhr.onerror = function (e: ErrorEvent) { onFailure(e); }; xhr.open("GET", path, true); xhr.send(null); } export function appendRelativePath(originalPath: ssortingng, relativePath: ssortingng, originalPathIsDirectory?: boolean) { if (originalPathIsDirectory == null) { originalPathIsDirectory = originalPath.charAt(originalPath.length - 1) == '/'; } if (!originalPathIsDirectory) { // remove file imediately var lastSlash = originalPath.lastIndexOf('/'); if (lastSlash >= 0) { originalPath = originalPath.subssortingng(0, lastSlash + 1); } else { originalPath = ""; } } var slashIndex = relativePath.indexOf('/'); if (slashIndex >= 0) { var relativeDirectory = relativePath.subssortingng(0, slashIndex + 1); var relativeRemainder = relativePath.subssortingng(slashIndex + 1); if (relativeDirectory == "../") { // sortingm off a directory on the original path if (originalPath.charAt(originalPath.length - 1) == '/') { originalPath = originalPath.subssortingng(0, originalPath.length - 1); } var dirIndex = originalPath.lastIndexOf('/'); if (dirIndex >= 0) { originalPath = originalPath.subssortingng(0, dirIndex + 1); } else { originalPath = ""; } } else { // append to the original path if (originalPath.charAt(originalPath.length - 1) != '/') { originalPath += '/'; } originalPath += relativeDirectory; } appendRelativePath(originalPath, relativeRemainder, true); } else { // append and be done if (originalPath.charAt(originalPath.length - 1) != '/') { originalPath += '/'; } return originalPath + relativePath; } } }