tiddlywiki 5.2.2 → 5.2.4

package/editions/dev/tiddlers/javascript-widget-tutorial/Widget refresh tutorial part I.tid

@@ -0,0 +1,47 @@
+created: 20190201232847949
+modified: 20221029203553291
+tags: 
+title: Widget refresh tutorial part I
+type: text/vnd.tiddlywiki
+
+But what if we want to display dynamic content? How can we display information and keep it up to date as it changes? Let's display the content of a tiddler field.
+
+The [[tiddlerfield-norefresh.js]] which defines the `tiddlerfield` widget is almost the same as [[hello.js]] except for this part:
+
+```javascript
+MyWidget.prototype.render = function(parent,nextSibling) {
+	this.parentDomNode = parent;
+	var text = this.wiki.getTiddlerText("test", "<empty>")
+	var textNode = this.document.createTextNode(text);
+	parent.insertBefore(textNode,nextSibling);
+	this.domNodes.push(textNode);
+};
+```
+
+Instead of creating the text dom node from a static string, the text field of the `test` tiddler is used. This is similar to using the view widget like this:  `<$view tiddler="test"/>`
+
+Here's how it looks (see [[Widget refresh demo I]] to look at the code):
+
+{{Widget refresh demo I}}
+
+Notice if you change the text in the input box, the output from the `tiddlerfield` widget doesn't change, but the output of the `view` widget does. Only after the ''Force refresh'' button is clicked does the output of `tiddlerfield` update to match the input box contents.
+
+What's going on here? The render method of the widget code is only called by tiddlywiki core when the widget is first created. After that, it isn't called again unless the widget is completely destroyed and then created again. 
+
+The tiddlywiki ~ViewWidget has a properly written `refresh` method so typing in the input box will cause its content to update. However, the `tiddlerfield` widget does not have a `refresh` method at all. It has no way of being notified that the `test` tiddler content has changed. Its output will not change until the ''Force refresh'' button is clicked.
+
+See the next example for an implementation of the `refresh` method for the `tiddlerfield` widget.
+
+The code for the refresh button looks like this:
+
+```
+<$button set="!!refresh" setTo={{test}}>Force refresh</$button>
+```
+
+and the widgets are enclosed in a list widget like this:
+
+```
+<$list filter="[{!!refresh}]">...</$list>
+```
+
+When the button is clicked the field `refresh` in the containing tiddler is modified and it causes the children of the list widget to be created from scratch. The render method is called and the output of the `tiddlerfield` widget updates.

package/editions/dev/tiddlers/javascript-widget-tutorial/Widget refresh tutorial part II.tid

@@ -0,0 +1,37 @@
+created: 20190201232910076
+modified: 20190217014335419
+tags: 
+title: Widget refresh tutorial part II
+type: text/vnd.tiddlywiki
+
+This example is like [[Widget refresh tutorial part I]] except the widget output will be automatically refreshed when the tiddler field changes.
+
+[[tiddlerfield.js]] is the same as [[tiddlerfield-norefresh.js]], except this `refresh` method is added:
+
+```javascript
+/*
+A widget with optimized performance will selectively refresh, but here we refresh always
+*/
+MyWidget.prototype.refresh = function(changedTiddlers) {
+	// Regenerate and rerender the widget and
+	// replace the existing DOM node
+	this.refreshSelf();
+	return true;
+};
+```
+
+The `refreshSelf` method called above is implemented by the core widget class and it takes care of cleaning the old dom node and calling the render function.
+
+Here is the result ([[Widget refresh demo II]]):
+
+{{Widget refresh demo II}}
+
+And now any typing into the input box will cause both the `tiddlerfield` and the `view` widget output to refresh immediately.
+
+Note this is a naive version of `refresh`. It unconditionally refreshes itself. This is far from optimal since the `refresh` method for all visible widgets is called every time the tiddler store changes. But the way we've defined our widget, the output ONLY depends on the tiddler titled `text`.
+
+In tiddlywiki the tiddler store is used for everything and almost any interaction will result in an update to the store. This means almost any interaction will cause the refresh method to be called. If you type into the search box, for example, the `tiddlerfield` widget will be refreshed with every keystroke.
+
+Adding and removing dom elements is a relatively expensive operation, so if someone has used the list widget to create a few hundred instances of this widget, then such tiddlywiki interactions might gain a noticable lag. Therefore, it usually makes sense to avoid modifying the dom when possible by writing a smarter `refresh` method. 
+
+''Exercise'' - change the refresh method above to only call `refreshSelf` when the `changedTiddlers` input array contains `test` as one of its entries (Hint: see the refresh method in $:/core/modules/widgets/view.js for an example).

package/editions/dev/tiddlers/javascript-widget-tutorial/Widget refresh tutorial part III.tid

@@ -0,0 +1,26 @@
+created: 20190202034841184
+modified: 20221029201023638
+tags: 
+title: Widget refresh tutorial part III
+type: text/vnd.tiddlywiki
+
+This tutorial is intended to demonstrate a few examples of when calls to the `refresh` method happen vs. when a widget is recreated from scratch.
+
+This is accomplished with a [[refreshcount.js]] widget which sets a counter to zero when the widget is created and increments the counter every time the `refresh` method is called. Here is the full code:
+
+{{refreshcount.js}}
+
+These are the key parts of the code from above:
+
+```javascript
+this.refreshCount = 0;
+this.document.createTextNode(this.refreshCount + " refreshes");
+this.refreshCount++;
+```
+
+In the following example (see [[Widget refresh demo III]] for the code), two instances of the `refreshcount` widget are created. One at the top level and the other inside a list widget whose filter results depend on the value in the `text` field of the `test` widget. The tiddler store can be modified in a few ways via two buttons and an input box:
+{{Widget refresh demo III}}
+
+* ''Modify a different tiddler'' - every time this button is clicked, both counters increment, indicating the `refresh` method is being called
+* ''Modify this tiddler'' - clicking this button modifies the tiddler itself. In earlier ~TiddlyWiki versions that caused both widgets to be recreated from scratch and the counters are thereby reset to zero. Since [[version 5.2.0|https://tiddlywiki.com/#Release%205.2.0]] modifying another field in this tiddler does not cause the widgets to be recreated and the counters are not reset.
+*  ''Text field of tiddler='test''' - typing text into the input box causes the counter in the standalone `refreshcount` widget to be incremented. But the other instance of the widget is embedded inside a list widget whose filter output depends on the value of the tiddler field which is being modified. This causes it to recreate its children from scratch and the counter is reset every time. So with every keystroke, the counter on the left is incremented, but the counter on the right goes to/stays at zero.

package/editions/dev/tiddlers/javascript-widget-tutorial/domwidget.js

@@ -0,0 +1,47 @@
+/*\
+
+Library function for creating widget using a dom creating function
+
+\*/
+(function() {
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+function createDomWidget(domCreatorFunction) {
+
+	var MyWidget = function(parseTreeNode, options) {
+		this.initialise(parseTreeNode, options);
+	};
+
+	/*
+	Inherit from the base widget class
+	*/
+	MyWidget.prototype = new Widget();
+
+	/*
+	Render this widget into the DOM
+	*/
+	MyWidget.prototype.render = function(parent, nextSibling) {
+		this.parentDomNode = parent;
+		var domNode = domCreatorFunction(this.document);
+		parent.insertBefore(domNode, nextSibling);
+		this.domNodes.push(domNode);
+	};
+
+	/*
+	A widget with optimized performance will selectively refresh, but here we refresh always
+	*/
+	MyWidget.prototype.refresh = function(changedTiddlers) {
+		// Regenerate and rerender the widget and replace the existing DOM node
+		this.refreshSelf();
+		return true;
+	};
+
+	return MyWidget;
+}
+module.exports = createDomWidget;
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/domwidget.js.meta

@@ -0,0 +1,6 @@
+created: 20190201025244440
+modified: 20190201030708723
+module-type: library
+tags: 
+title: domwidget.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/donothing.js

@@ -0,0 +1,16 @@
+/*\
+
+Do nothing widget
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+exports.donothing = Widget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/donothing.js.meta

@@ -0,0 +1,6 @@
+created: 20190201115945945
+modified: 20190201222441271
+module-type: widget
+tags: 
+title: donothing.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/hello-attribute-optimized.js

@@ -0,0 +1,51 @@
+/*\
+
+Hello, World widget
+
+\*/
+(function() {
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var MyWidget = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+/*
+Inherit from the base widget class
+*/
+MyWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+MyWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	var message = this.getAttribute("message", "World");
+	var textNode = this.document.createTextNode("Hello, " + message + "!");
+	parent.insertBefore(textNode, nextSibling);
+	this.domNodes.push(textNode);
+};
+
+/*
+Refresh if the attribute value changed since render
+*/
+MyWidget.prototype.refresh = function(changedTiddlers) {
+	// Find which attributes have changed
+	var changedAttributes = this.computeAttributes();
+	if (changedAttributes.message) {
+		this.refreshSelf();
+		return true;
+	} else {
+		return false;
+	}
+};
+
+exports.hello = MyWidget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/hello-attribute-optimized.js.meta

@@ -0,0 +1,6 @@
+created: 20190205024846183
+modified: 20190205025110882
+module-type: widget
+tags: 
+title: hello-attribute-optimized.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/hello-attribute.js

@@ -0,0 +1,47 @@
+/*\
+
+Hello, World widget
+
+\*/
+(function() {
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var MyWidget = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+/*
+Inherit from the base widget class
+*/
+MyWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+MyWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	var message = this.getAttribute("message", "World");
+	var textNode = this.document.createTextNode("Hello, " + message + "!");
+	parent.insertBefore(textNode, nextSibling);
+	this.domNodes.push(textNode);
+};
+
+/*
+A widget with optimized performance will selectively refresh, but here we refresh always
+*/
+MyWidget.prototype.refresh = function(changedTiddlers) {
+	// Regenerate and rerender the widget and
+	// replace the existing DOM node
+	this.refreshSelf();
+	return true;
+};
+
+exports.hello = MyWidget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/hello-attribute.js.meta

@@ -0,0 +1,6 @@
+created: 20190204020011193
+modified: 20190204030332147
+module-type: widget
+tags: 
+title: hello-attribute.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/hello.js

@@ -0,0 +1,35 @@
+/*\
+
+Hello, World widget
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var MyWidget = function(parseTreeNode,options) {
+	this.initialise(parseTreeNode,options);
+};
+
+/*
+Inherit from the base widget class
+*/
+MyWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+MyWidget.prototype.render = function(parent,nextSibling) {
+	this.parentDomNode = parent;
+	var textNode = this.document.createTextNode("Hello, World!");
+	parent.insertBefore(textNode,nextSibling);
+	this.domNodes.push(textNode);
+};
+
+exports.hello = MyWidget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/hello.js.meta

@@ -0,0 +1,6 @@
+created: 20190201114558816
+modified: 20190201224846870
+module-type: widget
+tags: 
+title: hello.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/refreshcount.js

@@ -0,0 +1,43 @@
+/*\
+
+widget to count the number of times this widget refreshes
+
+\*/
+(function() {
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var MyWidget = function(parseTreeNode, options) {
+	this.refreshCount = 0;
+	this.initialise(parseTreeNode, options);
+};
+
+/*
+Inherit from the base widget class
+*/
+MyWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+MyWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	var textNode = this.document.createTextNode(this.refreshCount + " refreshes");
+	parent.insertBefore(textNode, nextSibling);
+	this.domNodes.push(textNode);
+};
+
+MyWidget.prototype.refresh = function(changedTiddlers) {
+	// Regenerate and rerender the widget and replace the existing DOM node
+	this.refreshCount++;
+	this.refreshSelf();
+	return true;
+};
+
+exports.refreshcount = MyWidget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/refreshcount.js.meta

@@ -0,0 +1,6 @@
+created: 20190201005026324
+modified: 20190202143451303
+module-type: widget
+tags: 
+title: refreshcount.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/tiddlerfield-norefresh.js

@@ -0,0 +1,36 @@
+/*\
+
+Hello, World widget
+
+\*/
+(function() {
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var MyWidget = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+/*
+Inherit from the base widget class
+*/
+MyWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+MyWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	var text = this.wiki.getTiddlerText("test", "<empty>")
+	var textNode = this.document.createTextNode(text);
+	parent.insertBefore(textNode, nextSibling);
+	this.domNodes.push(textNode);
+};
+
+exports.tiddlerfield = MyWidget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/tiddlerfield-norefresh.js.meta

@@ -0,0 +1,6 @@
+created: 20190201233714872
+modified: 20190202030615781
+module-type: widget
+tags: 
+title: tiddlerfield-norefresh.js
+type: application/javascript

package/editions/dev/tiddlers/javascript-widget-tutorial/tiddlerfield.js

@@ -0,0 +1,46 @@
+/*\
+
+Hello, World widget
+
+\*/
+(function() {
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var MyWidget = function(parseTreeNode, options) {
+	this.initialise(parseTreeNode, options);
+};
+
+/*
+Inherit from the base widget class
+*/
+MyWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+MyWidget.prototype.render = function(parent, nextSibling) {
+	this.parentDomNode = parent;
+	var text = this.wiki.getTiddlerText("test", "<empty>")
+	var textNode = this.document.createTextNode(text);
+	parent.insertBefore(textNode, nextSibling);
+	this.domNodes.push(textNode);
+};
+
+/*
+A widget with optimized performance will selectively refresh, but here we refresh always
+*/
+MyWidget.prototype.refresh = function(changedTiddlers) {
+	// Regenerate and rerender the widget and
+	// replace the existing DOM node
+	this.refreshSelf();
+	return true;
+};
+
+exports.tiddlerfield = MyWidget;
+
+})();

package/editions/dev/tiddlers/javascript-widget-tutorial/tiddlerfield.js.meta

@@ -0,0 +1,6 @@
+created: 20190202032530728
+modified: 20190202032700995
+module-type: widget
+tags: 
+title: tiddlerfield.js
+type: application/javascript

package/editions/dev/tiddlers/system/github-fork-ribbon.tid

@@ -1,5 +1,5 @@
 title: $:/editions/dev/github-fork-ribbon
-tags: $:/tags/PageControls
+tags: $:/tags/PageTemplate
 caption: ~GitHub ribbon
 description: ~GitHub ribbon for tw5.com/dev
 

package/editions/dev/tiddlywiki.info

@@ -4,7 +4,9 @@
 		"tiddlywiki/highlight",
 		"tiddlywiki/nodewebkitsaver",
 		"tiddlywiki/github-fork-ribbon",
-		"tiddlywiki/internals"
+		"tiddlywiki/menubar",
+		"tiddlywiki/internals",
+		"tiddlywiki/innerwiki"
 	],
 	"themes": [
 		"tiddlywiki/vanilla",
@@ -22,7 +24,6 @@
 		"de-AT",
 		"de-DE",
 		"el-GR",
-		"en-GB",
 		"en-US",
 		"es-ES",
 		"fa-IR",

package/editions/es-ES/tiddlers/TiddlyDesktop.tid

@@ -12,7 +12,7 @@ Aquí hay un video de [[introducción a TiddlyDesktop|Introducing TiddlyDesktop
 
 ! Instrucciones
 
-# Descarga la última versión de TiddlyDesktop de https://github.com/Jermolene/TiddlyDesktop/releases
+# Descarga la última versión de TiddlyDesktop de https://github.com/TiddlyWiki/TiddlyDesktop/releases
 
 # Ejecuta TiddlyDesktop
 
@@ -24,6 +24,6 @@ Aquí hay un video de [[introducción a TiddlyDesktop|Introducing TiddlyDesktop
 
 ~TiddlyDesktop se basa en [[NW.js]], proyecto [[de código abierto|OpenSource]] y la fuente se encuentra en GitHub:
 
-https://github.com/Jermolene/TiddlyDesktop/
+https://github.com/TiddlyWiki/TiddlyDesktop/
 
 Consulta las [[versiones de TiddlyDesktop|TiddlyDesktop Releases]]

package/editions/fr-FR/tiddlers/$__editions_tw5.com_doc-macros.tid

@@ -117,7 +117,7 @@ C'est un exemple de tiddler. Voir [[Macros Table des matières (Exemples)|Table-
 <table class="doc-bad-example">
 <tbody>
 <tr class="evenRow">
-<td><span class="tc-inline-style" style="font-size:1.5em;">&#9888;</span> Attention&nbsp;:<br> Ne faites pas comme ça !</td>
+<td><span style="font-size:1.5em;">&#9888;</span> Attention&nbsp;:<br> Ne faites pas comme ça !</td>
 <td>
 
 $eg$

package/editions/fr-FR/tiddlers/Community Links Aggregator.tid

@@ -1,11 +1,11 @@
 created: 20210322151848025
 fr-title: Agrégateur de liens communautaire
-modified: 20220217174626896
+modified: 20220402105820520
 tags: Community
 title: Community Links Aggregator
 
-L'Agrégateur de liens communautaire est une collection fréquemment mise à jour de liens vers des ressources utiles et intéressantes sur <<tw>>, dénichés par notre équipe d'éditeurs communautaires. Le site agrège les liens soigneusement sélectionnés par les membres de la communauté <<tw>>. Il permet de visualiser les liens les plus récents, et de les explorer par catégorie et chronologiquement.
+L'Agrégateur de liens communautaire est une collection fréquemment mise à jour de liens vers des ressources utiles et intéressantes sur <<tw>>, dénichées par notre équipe d'éditeurs communautaires. Le site agrège les liens soigneusement sélectionnés par les membres de la communauté <<tw>>. Il permet de visualiser les liens les plus récents, et de les explorer par catégorie et chronologiquement.
 
-https://links.tiddlywiki.com/
+https://links.tiddlywiki.org/
 
-Plus les contributeurs sont nombreux, et mieux le site fonctionne<<!>> Comme chacun n'est pas tenu de recenser chaque lien qui passe, la pression individuelle sur les contributeurs est réduite. L'agrégation des liens réduit aussi l'impact d'une erreur, par exemple d'une erreur de catégorisation<<:>> si un contributeur catégorise un lien dans la mauvaise rubrique, le site permet de voir qu'une seule personne a utilisé cette rubrique, alors que la majorité utilise la catégorie appropriée. Ainsi, nous espérons qu'une sorte de //intelligence collective// émergera, avec un consensus sur la manière la plus utile de décrire et de catégoriser les liens.
+Plus les contributeurs sont nombreux, et mieux le site fonctionne<<!>> Comme chacun n'est pas tenu de recenser chaque lien qui passe, la pression individuelle sur les contributeurs est réduite. L'agrégation des liens réduit aussi l'impact d'une erreur, par exemple d'une erreur de catégorisation<<:>> si un contributeur catégorise un lien dans la mauvaise rubrique, le site permet de voir qu'une seule personne a utilisé cette rubrique, alors que la majorité utilise la catégorie appropriée. Ainsi, nous espérons qu'une sorte d'//intelligence collective// émergera, avec un consensus sur la manière la plus utile de décrire et de catégoriser les liens.

package/editions/fr-FR/tiddlers/Glossaire en-GB -_ fr-FR.tid

@@ -1,5 +1,5 @@
 created: 20141217193625476
-modified: 20220304170551125
+modified: 20220402105820520
 title: Glossaire en-GB -> fr-FR
 type: text/vnd.tiddlywiki
 
@@ -30,6 +30,7 @@ type: text/vnd.tiddlywiki
 |sequence|suite /série||
 |a set|un ensemble||
 |shadow|shadow|(ombre, *latent*, fantôme ?)|
+|single file wiki|wiki mono-fichier||
 |snippet|portion||
 |step|étape||
 |story river|déroulé||

package/editions/fr-FR/tiddlers/community/editions/_Noteself_ by Danielo Rodr/303/255guez.tid"

@@ -0,0 +1,34 @@
+caption: Noteself
+color: #29B6F6
+community-author: Danielo Rodríguez
+created: 20141122093837330
+delivery: Web Service
+description: Service en ligne gratuit que vous pouvez aussi héberger vous-même
+fr-title: "Noteself" par Danielo Rodríguez
+method: sync
+modified: 20220402105820520
+tags: Android Chrome Firefox [[Internet Explorer]] Linux Mac Opera PHP Safari Saving Windows iOS Edge [[Community Editions]] [[Other Resources]]
+title: "Noteself" by Danielo Rodríguez
+type: text/vnd.tiddlywiki
+url: https://noteself.github.io/
+
+~NoteSelf est votre version personnelle, privée, et personnalisable de l'expérience utilisateur d'Evernote. 
+Vous voulez du cloud<<?>> Bien<<!>> Vous n'en voulez pas<<?>> C'est bien aussi<<!>> C'est à vous, c'est votre choix<<!>>
+Pourquoi ne seriez-vous pas un peu égoïste<<?>>
+
+https://noteself.github.io/
+
+<<<
+~NoteSelf est le support parfait pour vos idées, vos notes, vos pensées, vos astuces, vos recettes... tout ce que vous voulez<<!>> 
+~NoteSelf les stockera, les indexera et les rendra faciles à rechercher, pour que vous les trouviez instantanément quand vous en avez besoin<<!>>
+
+Vous connaissez déjà Evernote et vous l'adorez, nous le savons bien. Il est confortable, il se synchronise, il permet la recherche...
+Ouah<<!>> Il est presque parfait, mais que pensez-vous de<<:>>
+
+* La vie privée<<:>> tout est stocké sur les serveurs d'Evernote<<!>>
+* La personnalisation<<:>> si vous n'aimez pas l'interface d'Evernote, il n'y a rien à faire.
+
+~NoteSelf est construit sur la base de <<tw>>, un logiciel libre de wiki personnel puissant, gratuit et hautement personnalisable.
+Nous en avons tiré le meilleur, son système puissant de personnalisation, et l'avons combiné avec une des meilleures
+bases de données embarquées disponibles, [[PouchDb|http://www.pouchdb.com]], pour y apporter les capacités de synchronisation dont vous avez besoin.
+<<<

package/editions/fr-FR/tiddlers/community/resources/TW5-firebase_ TiddlyWiki5 for Google Firebase by Peter Neumark.tid

@@ -0,0 +1,28 @@
+caption: TW5-firebase
+color: #FFEB3B
+community-author: Peter Neumark
+created: 20210115121027582
+delivery: Google Firebase backend
+description: Plateforme Google Firebase pour TiddlyWiki
+fr-title: TW5-firebase: TiddlyWiki5 sur Google Firebase par Peter Neumark
+method: save
+modified: 20220402105820520
+tags: Chrome Firefox [[Internet Explorer]] Linux Mac Opera [[Other Resources]] Safari Saving Windows plugins Edge
+title: TW5-firebase: TiddlyWiki5 for Google Firebase by Peter Neumark
+type: text/vnd.tiddlywiki
+url: https://github.com/neumark/tw5-firebase
+
+Une version de TiddlyWiki5 hébergée sur Google-Firebase.
+
+{{!!url}}
+
+<<<
+J'utilise TiddlyWiki5 avec Google Firebase depuis plus d'un an. C'est suffisamment stable pour l'utiliser au quotidien. Il y a un accompagnement détaillé sur la façon de créer sa propre instance avec de nombreuses captures d'écran. Le processus complet prend moins de 30 minutes<<:>> https://neumark.github.io/tw5-firebase/
+
+Merci de considérer cette version comme une preuve de concept plus qu'un produit fini<<!>> Je me suis concentré sur la collaboration multi-appareils ou en petites équipes<<:>>
+
+* Authentification de base (les sacs ont une politique d'accès qui détermine qui peut les lire ou les écrire).
+* De multiples wikis peuvent être hébergés avec le même compte Firebase.
+* Utilise l'authentification sociale intégrée à Firebase pour identifier les utilisateurs.
+* Les tiddlers sont verrouillés individuellement en écriture, pour éviter que les utilisateurs écrasent mutuellement leurs modifications.
+<<< Traduction de [[l'annonce de publication par Peter Neumark|https://groups.google.com/g/tiddlywikidev/c/2WN2b6uCxJ8]]