2011-12-13 12:30:09 +00:00
|
|
|
/*\
|
|
|
|
title: js/WikiStore.js
|
|
|
|
|
2012-01-17 13:01:55 +00:00
|
|
|
WikiStore uses the .cache member of tiddlers to store the following information:
|
|
|
|
|
|
|
|
parseTree: Caches the parse tree for the tiddler
|
|
|
|
renderers: Caches rendering functions for this tiddler (indexed by MIME type)
|
|
|
|
renditions: Caches the renditions produced by those functions (indexed by MIME type)
|
|
|
|
|
2011-12-13 12:30:09 +00:00
|
|
|
\*/
|
2011-12-12 10:52:04 +00:00
|
|
|
(function(){
|
|
|
|
|
2011-12-09 16:34:02 +00:00
|
|
|
/*jslint node: true */
|
2011-11-30 17:27:00 +00:00
|
|
|
"use strict";
|
|
|
|
|
2011-12-05 16:50:25 +00:00
|
|
|
var Tiddler = require("./Tiddler.js").Tiddler,
|
2012-01-06 17:53:37 +00:00
|
|
|
utils = require("./Utils.js");
|
2011-11-22 14:29:29 +00:00
|
|
|
|
2011-12-28 17:16:56 +00:00
|
|
|
/* Creates a new WikiStore object
|
|
|
|
|
|
|
|
Available options are:
|
|
|
|
shadowStore: An existing WikiStore to use for shadow tiddler storage. Pass null to prevent a default shadow store from being created
|
|
|
|
*/
|
2011-12-11 18:28:09 +00:00
|
|
|
var WikiStore = function WikiStore(options) {
|
2011-12-28 17:16:56 +00:00
|
|
|
options = options || {};
|
2012-01-17 13:31:06 +00:00
|
|
|
this.tiddlers = {}; // Hashmap of tiddlers by title
|
|
|
|
this.parsers = {}; // Hashmap of parsers by accepted MIME type
|
|
|
|
this.macros = {}; // Hashmap of macros by macro name
|
|
|
|
this.caches = {}; // Hashmap of cache objects by tiddler title, each is a hashmap of named caches
|
|
|
|
this.tiddlerSerializers = {}; // Hashmap of serializers by target MIME type
|
|
|
|
this.tiddlerDeserializers = {}; // Hashmap of deserializers by accepted MIME type
|
2012-01-14 15:49:12 +00:00
|
|
|
this.eventListeners = []; // Array of {filter:,listener:}
|
|
|
|
this.eventsTriggered = false;
|
|
|
|
this.changedTiddlers = {}; // Hashmap of {title: "created|modified|deleted"}
|
2011-12-11 18:28:09 +00:00
|
|
|
this.shadows = options.shadowStore !== undefined ? options.shadowStore : new WikiStore({
|
2011-12-28 17:16:56 +00:00
|
|
|
shadowStore: null
|
2011-12-11 18:28:09 +00:00
|
|
|
});
|
2011-11-22 14:29:29 +00:00
|
|
|
};
|
|
|
|
|
2012-01-05 11:08:05 +00:00
|
|
|
WikiStore.prototype.registerParser = function(type,parser) {
|
|
|
|
this.parsers[type] = parser;
|
2011-12-28 17:16:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.registerTiddlerSerializer = function(extension,mimeType,serializer) {
|
|
|
|
this.tiddlerSerializers[extension] = serializer;
|
|
|
|
this.tiddlerSerializers[mimeType] = serializer;
|
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.registerTiddlerDeserializer = function(extension,mimeType,deserializer) {
|
|
|
|
this.tiddlerDeserializers[extension] = deserializer;
|
|
|
|
this.tiddlerDeserializers[mimeType] = deserializer;
|
2011-12-01 10:19:21 +00:00
|
|
|
};
|
2011-11-22 14:29:29 +00:00
|
|
|
|
2012-01-14 15:49:12 +00:00
|
|
|
WikiStore.prototype.addEventListener = function(filter,listener) {
|
|
|
|
this.eventListeners.push({
|
|
|
|
filter: filter,
|
|
|
|
listener: listener
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.removeEventListener = function(listener) {
|
|
|
|
for(var c=this.eventListeners.length-1; c>=0; c--) {
|
|
|
|
var l = this.eventListeners[c];
|
|
|
|
if(l.listener === listener) {
|
|
|
|
this.eventListeners.splice(c,1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
Causes a tiddler to be marked as changed, so that event listeners are triggered for it
|
|
|
|
type: Type of change to be registered for the tiddler "created", "modified" or "deleted"
|
|
|
|
If the tiddler is already touched, the resultant touch type is as follows:
|
|
|
|
|
|
|
|
If the tiddler is already marked "created",
|
|
|
|
... attempts to mark it "modified" leave it "created"
|
|
|
|
... attempts to mark it "deleted" succeed
|
|
|
|
|
|
|
|
If the tiddler is already marked "modified",
|
|
|
|
... attempts to mark it "deleted" succeed
|
|
|
|
|
|
|
|
If the tiddler is already marked "deleted",
|
|
|
|
... attempts to mark it "created" succeed
|
|
|
|
... attempts to mark it "modified" fail
|
|
|
|
|
|
|
|
*/
|
|
|
|
WikiStore.prototype.touchTiddler = function(type,title) {
|
|
|
|
var existingType = this.changedTiddlers[title];
|
|
|
|
if(existingType === undefined && type === "modified") {
|
|
|
|
type = "created";
|
|
|
|
}
|
|
|
|
if(existingType === "modified" && type === "created") {
|
|
|
|
type = "modified";
|
|
|
|
}
|
|
|
|
if(existingType === "deleted" && type === "created") {
|
|
|
|
type = "modified";
|
|
|
|
}
|
|
|
|
this.changedTiddlers[title] = type;
|
|
|
|
this.triggerEvents();
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
Trigger the execution of the event dispatcher at the next tick, if it is not already triggered
|
|
|
|
*/
|
|
|
|
WikiStore.prototype.triggerEvents = function() {
|
|
|
|
if(!this.eventsTriggered) {
|
|
|
|
var me = this;
|
|
|
|
utils.nextTick(function() {
|
|
|
|
var changes = me.changedTiddlers;
|
|
|
|
me.changedTiddlers = {};
|
|
|
|
me.eventsTriggered = false;
|
|
|
|
for(var e=0; e<me.eventListeners.length; e++) {
|
|
|
|
var listener = me.eventListeners[e];
|
|
|
|
listener.listener(changes);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
this.eventsTriggered = true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-12-06 18:29:53 +00:00
|
|
|
WikiStore.prototype.getTiddler = function(title) {
|
2011-11-22 14:29:29 +00:00
|
|
|
var t = this.tiddlers[title];
|
2011-12-03 17:02:34 +00:00
|
|
|
if(t instanceof Tiddler) {
|
|
|
|
return t;
|
|
|
|
} else if(this.shadows) {
|
|
|
|
return this.shadows.getTiddler(title);
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
2011-12-01 10:19:21 +00:00
|
|
|
};
|
2011-11-22 14:29:29 +00:00
|
|
|
|
2011-12-06 18:29:53 +00:00
|
|
|
WikiStore.prototype.getTiddlerText = function(title) {
|
2011-12-03 17:02:34 +00:00
|
|
|
var t = this.getTiddler(title);
|
2012-01-17 13:01:55 +00:00
|
|
|
return t instanceof Tiddler ? t.text : null;
|
2011-12-01 15:07:10 +00:00
|
|
|
};
|
|
|
|
|
2011-12-06 18:29:53 +00:00
|
|
|
WikiStore.prototype.deleteTiddler = function(title) {
|
2011-11-22 14:29:29 +00:00
|
|
|
delete this.tiddlers[title];
|
2011-12-01 10:19:21 +00:00
|
|
|
};
|
2011-11-22 14:29:29 +00:00
|
|
|
|
2011-12-06 18:29:53 +00:00
|
|
|
WikiStore.prototype.tiddlerExists = function(title) {
|
2011-12-16 10:48:36 +00:00
|
|
|
var exists = this.tiddlers[title] instanceof Tiddler;
|
|
|
|
if(exists) {
|
|
|
|
return true;
|
|
|
|
} else if (this.shadows) {
|
|
|
|
return this.shadows.tiddlerExists(title);
|
|
|
|
}
|
|
|
|
return ;
|
2011-12-02 14:40:18 +00:00
|
|
|
};
|
2011-12-01 15:07:10 +00:00
|
|
|
|
2011-12-06 18:29:53 +00:00
|
|
|
WikiStore.prototype.addTiddler = function(tiddler) {
|
2012-01-17 13:01:55 +00:00
|
|
|
this.tiddlers[tiddler.title] = tiddler;
|
|
|
|
this.touchTiddler("modified",tiddler.title);
|
2011-12-01 10:19:21 +00:00
|
|
|
};
|
2011-11-22 14:29:29 +00:00
|
|
|
|
2011-12-12 08:59:28 +00:00
|
|
|
WikiStore.prototype.forEachTiddler = function(/* [sortField,[excludeTag,]]callback */) {
|
|
|
|
var a = 0,
|
|
|
|
sortField = arguments.length > 1 ? arguments[a++] : null,
|
|
|
|
excludeTag = arguments.length > 2 ? arguments[a++] : null,
|
|
|
|
callback = arguments[a++],
|
2012-01-05 21:31:47 +00:00
|
|
|
t,
|
|
|
|
tiddlers = [],
|
|
|
|
tiddler;
|
2011-12-12 08:59:28 +00:00
|
|
|
if(sortField) {
|
|
|
|
for(t in this.tiddlers) {
|
|
|
|
tiddlers.push(this.tiddlers[t]);
|
|
|
|
}
|
2012-01-17 13:01:55 +00:00
|
|
|
tiddlers.sort(function (a,b) {return Tiddler.compareTiddlerFields(a,b,sortField);});
|
2011-12-12 08:59:28 +00:00
|
|
|
for(t=0; t<tiddlers.length; t++) {
|
|
|
|
if(!tiddlers[t].hasTag(excludeTag)) {
|
2012-01-17 13:01:55 +00:00
|
|
|
callback.call(this,tiddlers[t].title,tiddlers[t]);
|
2011-12-12 08:59:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for(t in this.tiddlers) {
|
|
|
|
tiddler = this.tiddlers[t];
|
|
|
|
if(tiddler instanceof Tiddler && !tiddler.hasTag(excludeTag))
|
|
|
|
callback.call(this,t,tiddler);
|
|
|
|
}
|
2011-11-22 14:29:29 +00:00
|
|
|
}
|
2011-12-01 10:19:21 +00:00
|
|
|
};
|
2011-11-22 14:29:29 +00:00
|
|
|
|
2011-12-14 18:25:40 +00:00
|
|
|
WikiStore.prototype.getTitles = function(sortField,excludeTag) {
|
2011-12-28 16:10:30 +00:00
|
|
|
sortField = sortField || "title";
|
2011-12-14 18:25:40 +00:00
|
|
|
var tiddlers = [];
|
|
|
|
this.forEachTiddler(sortField,excludeTag,function(title,tiddler) {
|
|
|
|
tiddlers.push(title);
|
|
|
|
});
|
|
|
|
return tiddlers;
|
|
|
|
};
|
|
|
|
|
2011-12-28 16:10:30 +00:00
|
|
|
WikiStore.prototype.getMissingTitles = function() {
|
|
|
|
return [];
|
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.getOrphanTitles = function() {
|
|
|
|
return [];
|
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.getShadowTitles = function() {
|
|
|
|
return this.shadows ? this.shadows.getTitles() : [];
|
|
|
|
};
|
|
|
|
|
2011-12-28 17:16:56 +00:00
|
|
|
WikiStore.prototype.serializeTiddler = function(type,tiddler) {
|
|
|
|
var serializer = this.tiddlerSerializers[type];
|
|
|
|
if(serializer) {
|
|
|
|
return serializer(tiddler);
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.deserializeTiddlers = function(type,text,srcFields) {
|
|
|
|
var fields = {},
|
|
|
|
deserializer = this.tiddlerDeserializers[type],
|
|
|
|
t;
|
|
|
|
if(srcFields) {
|
|
|
|
for(t in srcFields) {
|
|
|
|
fields[t] = srcFields[t];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(deserializer) {
|
|
|
|
return deserializer(text,fields);
|
|
|
|
} else {
|
|
|
|
// Return a raw tiddler for unknown types
|
|
|
|
fields.text = text;
|
|
|
|
return [fields];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-01-14 15:49:12 +00:00
|
|
|
WikiStore.prototype.adjustClassesForLink = function(classes,target) {
|
2012-01-15 13:48:13 +00:00
|
|
|
var newClasses = classes.slice(0),
|
|
|
|
externalRegExp = /(?:file|http|https|mailto|ftp|irc|news|data):[^\s'"]+(?:\/|\b)/i,
|
2012-01-14 15:49:12 +00:00
|
|
|
setClass = function(className) {
|
2012-01-15 13:48:13 +00:00
|
|
|
if(newClasses.indexOf(className) === -1) {
|
|
|
|
newClasses.push(className);
|
2012-01-14 15:49:12 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
removeClass = function(className) {
|
2012-01-15 13:48:13 +00:00
|
|
|
var p = newClasses.indexOf(className);
|
2012-01-14 15:49:12 +00:00
|
|
|
if(p !== -1) {
|
2012-01-15 13:48:13 +00:00
|
|
|
newClasses.splice(p,1);
|
2012-01-14 15:49:12 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
// Make sure we've got the main link class
|
|
|
|
setClass("tw-tiddlylink");
|
|
|
|
// Check if it's an internal link
|
2012-01-07 10:35:02 +00:00
|
|
|
if (this.tiddlerExists(target)) {
|
2012-01-14 15:49:12 +00:00
|
|
|
removeClass("tw-tiddlylink-external");
|
|
|
|
setClass("tw-tiddlylink-internal");
|
|
|
|
setClass("tw-tiddlylink-resolves");
|
|
|
|
removeClass("tw-tiddlylink-missing");
|
2012-01-07 10:35:02 +00:00
|
|
|
} else if(externalRegExp.test(target)) {
|
2012-01-14 15:49:12 +00:00
|
|
|
setClass("tw-tiddlylink-external");
|
|
|
|
removeClass("tw-tiddlylink-internal");
|
|
|
|
removeClass("tw-tiddlylink-resolves");
|
|
|
|
removeClass("tw-tiddlylink-missing");
|
2012-01-05 20:10:25 +00:00
|
|
|
} else {
|
2012-01-14 15:49:12 +00:00
|
|
|
removeClass("tw-tiddlylink-external");
|
|
|
|
setClass("tw-tiddlylink-internal");
|
|
|
|
removeClass("tw-tiddlylink-resolves");
|
|
|
|
setClass("tw-tiddlylink-missing");
|
2012-01-05 20:10:25 +00:00
|
|
|
}
|
2012-01-15 13:48:13 +00:00
|
|
|
return newClasses;
|
2012-01-03 11:09:59 +00:00
|
|
|
};
|
|
|
|
|
2012-01-17 13:31:06 +00:00
|
|
|
// Return the named cache object for a tiddler. If the cache doesn't exist then the initializer function is invoked to create it
|
|
|
|
WikiStore.prototype.getCacheForTiddler = function(title,cacheName,initializer) {
|
|
|
|
var caches = this.caches[title];
|
|
|
|
if(caches && caches[cacheName]) {
|
|
|
|
return caches[cacheName];
|
|
|
|
} else {
|
|
|
|
if(!caches) {
|
|
|
|
caches = {};
|
|
|
|
this.caches[title] = caches;
|
|
|
|
}
|
|
|
|
caches[cacheName] = initializer();
|
|
|
|
return caches[cacheName];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-12-28 17:16:56 +00:00
|
|
|
WikiStore.prototype.parseText = function(type,text) {
|
2012-01-05 11:08:05 +00:00
|
|
|
var parser = this.parsers[type];
|
|
|
|
if(!parser) {
|
|
|
|
parser = this.parsers["text/x-tiddlywiki"];
|
2011-12-28 17:16:56 +00:00
|
|
|
}
|
2012-01-05 11:08:05 +00:00
|
|
|
if(parser) {
|
|
|
|
return parser.parse(text);
|
2011-12-28 17:16:56 +00:00
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-12-11 18:28:09 +00:00
|
|
|
WikiStore.prototype.parseTiddler = function(title) {
|
2012-01-17 13:31:06 +00:00
|
|
|
var me = this,
|
|
|
|
tiddler = this.getTiddler(title),
|
|
|
|
parseTree = this.getCacheForTiddler(title,"parseTree",function() {
|
|
|
|
return me.parseText(tiddler.type,tiddler.text);
|
|
|
|
});
|
|
|
|
return parseTree;
|
2011-12-12 10:52:04 +00:00
|
|
|
};
|
2011-12-11 18:28:09 +00:00
|
|
|
|
2012-01-07 20:08:11 +00:00
|
|
|
/*
|
|
|
|
Compiles a block of text of a specified type into a JavaScript function that renders the text in a particular MIME type
|
|
|
|
*/
|
|
|
|
WikiStore.prototype.compileText = function(type,text,targetType) {
|
|
|
|
/*jslint evil: true */
|
|
|
|
var tree = this.parseText(type,text);
|
|
|
|
return eval(tree.compile(targetType));
|
|
|
|
};
|
|
|
|
|
2012-01-06 17:40:22 +00:00
|
|
|
/*
|
|
|
|
Compiles a JavaScript function that renders a tiddler in a particular MIME type
|
|
|
|
*/
|
|
|
|
WikiStore.prototype.compileTiddler = function(title,type) {
|
|
|
|
/*jslint evil: true */
|
2012-01-17 13:31:06 +00:00
|
|
|
var tiddler = this.getTiddler(title),
|
|
|
|
renderers = this.getCacheForTiddler(title,"renderers",function() {
|
|
|
|
return {};
|
|
|
|
});
|
2012-01-06 17:40:22 +00:00
|
|
|
if(tiddler) {
|
2012-01-17 13:31:06 +00:00
|
|
|
if(!renderers[type]) {
|
2012-01-17 15:35:13 +00:00
|
|
|
var tree = this.parseTiddler(title),
|
|
|
|
text = tree.compile(type);
|
|
|
|
// Add a source URL to help debugging (see http://blog.getfirebug.com/2009/08/11/give-your-eval-a-name-with-sourceurl/)
|
|
|
|
text += "//@ sourceURL=" + encodeURIComponent(title) + "-" + type;
|
|
|
|
renderers[type] = eval(text);
|
2012-01-06 17:40:22 +00:00
|
|
|
}
|
2012-01-17 13:31:06 +00:00
|
|
|
return renderers[type];
|
2012-01-06 17:40:22 +00:00
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-01-07 20:08:11 +00:00
|
|
|
/*
|
|
|
|
Render a block of text of a specified type into a particular MIME type
|
|
|
|
*/
|
|
|
|
WikiStore.prototype.renderText = function(type,text,targetType,asTitle) {
|
|
|
|
var tiddler = this.getTiddler(asTitle),
|
|
|
|
fn = this.compileText(type,text,targetType);
|
|
|
|
return fn(tiddler,this,utils);
|
|
|
|
};
|
|
|
|
|
2011-12-14 14:11:11 +00:00
|
|
|
/*
|
2012-01-04 19:44:38 +00:00
|
|
|
Render a tiddler to a particular MIME type. Optionally render it with a different tiddler
|
2012-01-06 17:40:22 +00:00
|
|
|
as the context. This option is used to render a tiddler through a template eg
|
2012-01-04 19:44:38 +00:00
|
|
|
store.renderTiddler("text/html",templateTitle,tiddlerTitle)
|
2011-12-14 14:11:11 +00:00
|
|
|
*/
|
2012-01-14 17:24:07 +00:00
|
|
|
WikiStore.prototype.renderTiddler = function(targetType,title,asTitle) {
|
2012-01-06 17:40:22 +00:00
|
|
|
var tiddler = this.getTiddler(title),
|
2012-01-17 13:31:06 +00:00
|
|
|
fn = this.compileTiddler(title,targetType),
|
|
|
|
renditions = this.getCacheForTiddler(title,"renditions",function() {
|
|
|
|
return {};
|
|
|
|
});
|
2012-01-06 18:43:36 +00:00
|
|
|
if(tiddler) {
|
|
|
|
if(asTitle) {
|
|
|
|
var asTiddler = this.getTiddler(asTitle);
|
|
|
|
return fn(asTiddler,this,utils);
|
|
|
|
} else {
|
2012-01-17 13:31:06 +00:00
|
|
|
if(!renditions[targetType]) {
|
|
|
|
renditions[targetType] = fn(tiddler,this,utils);
|
2012-01-06 18:43:36 +00:00
|
|
|
}
|
2012-01-17 13:31:06 +00:00
|
|
|
return renditions[targetType];
|
2012-01-06 17:40:22 +00:00
|
|
|
}
|
2011-12-11 18:28:09 +00:00
|
|
|
}
|
2012-01-06 18:43:36 +00:00
|
|
|
return null;
|
2011-12-12 10:52:04 +00:00
|
|
|
};
|
2011-12-11 18:28:09 +00:00
|
|
|
|
2012-01-15 13:37:50 +00:00
|
|
|
/*
|
|
|
|
Executes a macro and returns the result
|
|
|
|
*/
|
2012-01-15 18:39:14 +00:00
|
|
|
WikiStore.prototype.renderMacro = function(macroName,targetType,tiddler,params,content) {
|
2012-01-15 13:37:50 +00:00
|
|
|
var macro = this.macros[macroName];
|
|
|
|
if(macro) {
|
2012-01-15 18:39:14 +00:00
|
|
|
return macro.handler(targetType,tiddler,this,params,content);
|
2012-01-15 13:37:50 +00:00
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
2012-01-15 14:37:49 +00:00
|
|
|
};
|
2012-01-15 13:37:50 +00:00
|
|
|
|
2012-01-14 15:49:12 +00:00
|
|
|
/*
|
|
|
|
Refresh a DOM node so that it reflects the current state of the store
|
|
|
|
|
|
|
|
The refresh processing is:
|
|
|
|
|
|
|
|
1. If the node is a link, check the link classes correctly reflect the status of the target tiddler. Recursively process any children. Exit
|
|
|
|
2. If the node is a macro, and dependencies have changed, re-render the macro into the DOM node. Exit
|
|
|
|
3. If the node is a macro and the dependencies haven't changed, recursively process each child node of the macro. Exit
|
|
|
|
|
|
|
|
Arguments
|
|
|
|
node - the DOM node to be processed
|
|
|
|
tiddler - the tiddler providing context for the rendering
|
|
|
|
|
|
|
|
*/
|
|
|
|
WikiStore.prototype.refreshDomNode = function(node,tiddler) {
|
|
|
|
// Process macros
|
|
|
|
var macro = node.getAttribute && node.getAttribute("data-tw-macro"),
|
|
|
|
params = node.getAttribute && node.getAttribute("data-tw-params");
|
|
|
|
if(macro && params) {
|
|
|
|
}
|
|
|
|
// Process children
|
|
|
|
if(node.hasChildNodes()) {
|
|
|
|
this.refreshDomChildren(node,tiddler);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
WikiStore.prototype.refreshDomChildren = function(node,tiddler) {
|
|
|
|
var nodes = node.childNodes;
|
|
|
|
for(var c=0; c<nodes.length; c++) {
|
|
|
|
this.refreshDomNode(nodes[c],tiddler);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-01-07 17:33:42 +00:00
|
|
|
WikiStore.prototype.installMacro = function(macro) {
|
|
|
|
this.macros[macro.name] = macro;
|
2012-01-03 11:09:59 +00:00
|
|
|
};
|
|
|
|
|
2011-12-06 18:29:53 +00:00
|
|
|
exports.WikiStore = WikiStore;
|
2011-12-12 10:52:04 +00:00
|
|
|
|
|
|
|
})();
|