diff --git a/transitions/2024/FPWD/common.js b/transitions/2024/FPWD/common.js new file mode 100644 index 0000000..6d34670 --- /dev/null +++ b/transitions/2024/FPWD/common.js @@ -0,0 +1,247 @@ +/* globals omitTerms, respecConfig, $, require */ +/* exported linkCrossReferences, restrictReferences, fixIncludes */ + +var ccg = { + // Add as the respecConfig localBiblio variable + // Extend or override global respec references + localBiblio: { + "REST": { + title: "Architectural Styles and the Design of Network-based Software Architectures", + date: "2000", + href: "http://www.ics.uci.edu/~fielding/pubs/dissertation/", + authors: [ + "Fielding, Roy Thomas" + ], + publisher: "University of California, Irvine." + }, + "DID-METHOD-REGISTRY": { + title: "The Decentralized Identifier Method Registry", + href: "https://w3c-ccg.github.io/did-method-registry/", + authors: [ + "Manu Sporny", + "Drummond Reed" + ], + status: "CG-DRAFT", + publisher: "Digital Verification Community Group" + }, + "MATRIX-URIS": { + title: "Matrix URIs - Ideas about Web Architecture", + date: "December 1996", + href: "https://www.w3.org/DesignIssues/MatrixURIs.html", + authors: [ + "Tim Berners-Lee" + ], + status: "Personal View" + }, + "COOL-URIS": { + title: "Cool URIs for the Semantic Web", + date: "December 2008", + href: "https://www.w3.org/TR/cooluris/", + authors: [ + "Leo Sauermann", + "Richard Cyganiak" + ], + status: "Interest Group Note" + }, + "KERI": { + title: "Key Event Receipt Infrastructure (KERI)", + date: "July 2019", + href: "https://arxiv.org/abs/1907.02143", + authors: [ + "Samuel M. Smith" + ] + }, + "DID-PEER": { + title: "Peer DID Method Specification", + subtitle: "blockchain-independent decentralized identifiers", + date: "10 July 2020", + href: "https://identity.foundation/peer-did-method-spec/", + editors: [ + "Daniel Hardman", + ], + authors: [ + "Oskar Deventer", + "Christian Lundkvist", + "Márton Csernai", + "Kyle Den Hartog", + "Markus Sabadello", + "Sam Curren", + "Dan Gisolfi", + "Mike Varley", + "Sven Hammann", + "John Jordan", + "Lovesh Harchandani", + "Devin Fisher", + "Tobias Looker", + "Brent Zundel", + "Stephen Curran" + ], + status: "ED" + }, + "DID-KEY": { + title: "The did:key Method", + subtitle: "A DID Method for Static Cryptographic Keys", + date: " 09 June 2020", + href: "https://w3c-ccg.github.io/did-method-key/", + editors: [ + "Manu Sporny", + "Dmitri Zagidulin", + "Dave Longley" + ], + authors: [ + "Manu Sporny", + "Dmitri Zagidulin", + "Dave Longley" + ], + status: "unofficial" + } + } +}; + + + +// We should be able to remove terms that are not actually +// referenced from the common definitions +// +// the termlist is in a block of class "termlist", so make sure that +// has an ID and put that ID into the termLists array so we can +// interrogate all of the included termlists later. +var termNames = [] ; +var termLists = [] ; +var termsReferencedByTerms = [] ; + +function restrictReferences(utils, content) { + "use strict"; + var base = document.createElement("div"); + base.innerHTML = content; + + // New new logic: + // + // 1. build a list of all term-internal references + // 2. When ready to process, for each reference INTO the terms, + // remove any terms they reference from the termNames array too. + $.each(base.querySelectorAll("dfn"), function(i, item) { + var $t = $(item) ; + var titles = $t.getDfnTitles(); + var dropit = false; + // do we have an omitTerms + if (window.hasOwnProperty("omitTerms")) { + // search for a match + $.each(omitTerms, function(j, term) { + if (titles.indexOf(term) !== -1) { + dropit = true; + } + }); + } + // do we have an includeTerms + if (window.hasOwnProperty("includeTerms")) { + var found = false; + // search for a match + $.each(includeTerms, function(j, term) { + if (titles.indexOf(term) !== -1) { + found = true; + } + }); + if (!found) { + dropit = true; + } + } + if (dropit) { + $t.parent().next().remove(); + $t.parent().remove(); + } else { + var n = $t.makeID("dfn", titles[0]); + if (n) { + termNames[n] = $t.parent() ; + } + } + }); + + var $container = $(".termlist",base) ; + var containerID = $container.makeID("", "terms") ; + termLists.push(containerID) ; + + return (base.innerHTML); +} +// add a handler to come in after all the definitions are resolved +// +// New logic: If the reference is within a 'dl' element of +// class 'termlist', and if the target of that reference is +// also within a 'dl' element of class 'termlist', then +// consider it an internal reference and ignore it. + +require(["core/pubsubhub"], function(respecEvents) { + "use strict"; + respecEvents.sub('end', function(message) { + if (message === 'core/link-to-dfn') { + // all definitions are linked; find any internal references + $(".termlist a.internalDFN").each(function() { + var $r = $(this); + var id = $r.attr('href'); + var idref = id.replace(/^#/,"") ; + if (termNames[idref]) { + // this is a reference to another term + // what is the idref of THIS term? + var $def = $r.closest('dd') ; + if ($def.length) { + var $p = $def.prev('dt').find('dfn') ; + var tid = $p.attr('id') ; + if (tid) { + if (termsReferencedByTerms[tid]) { + termsReferencedByTerms[tid].push(idref); + } else { + termsReferencedByTerms[tid] = [] ; + termsReferencedByTerms[tid].push(idref); + } + } + } + } + }) ; + + // clearRefs is recursive. Walk down the tree of + // references to ensure that all references are resolved. + var clearRefs = function(theTerm) { + if ( termsReferencedByTerms[theTerm] ) { + $.each(termsReferencedByTerms[theTerm], function(i, item) { + if (termNames[item]) { + delete termNames[item]; + clearRefs(item); + } + }); + } + // make sure this term doesn't get removed + if (termNames[theTerm]) { + delete termNames[theTerm]; + } + }; + + // now termsReferencedByTerms has ALL terms that + // reference other terms, and a list of the + // terms that they reference + $("a.internalDFN").each(function () { + var $item = $(this) ; + var t = $item.attr('href'); + var r = t.replace(/^#/,"") ; + // if the item is outside the term list + if ( ! $item.closest('dl.termlist').length ) { + clearRefs(r); + } + }); + + // delete any terms that were not referenced. + Object.keys(termNames).forEach(function(term) { + var $p = $("#"+term) ; + if ($p) { + var tList = $p.getDfnTitles(); + $p.parent().next().remove(); + $p.parent().remove() ; + tList.forEach(function( item ) { + if (respecConfig.definitionMap[item]) { + delete respecConfig.definitionMap[item]; + } + }); + } + }); + } + }); +});