├── .gitignore
├── .gitmodules
├── AddPlugin.sh
├── MakePlugin.sh
├── MakePluginLibrary.sh
├── MakeWiki.sh
├── PluginLibrary
    └── tiddlywiki.info
├── Readme.md
├── Setup.sh
├── UtilityTiddlers
    ├── MakeLibrary.tid
    └── MakePlugin.tid
└── start.sh


/.gitignore:
--------------------------------------------------------------------------------
 1 | LanguageFolder.txt
 2 | PluginFolder.txt
 3 | ThemeFolder.txt
 4 | Author.txt
 5 | TiddlyWikiVersion.txt
 6 | Wikis/
 7 | Plugins/
 8 | Themes/
 9 | Languages/
10 | PluginLibrary/output
11 | test.sh


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "TiddlyWiki5"]
2 | 	path = TiddlyWiki5
3 | 	url = https://github.com/Jermolene/TiddlyWiki5.git
4 | 


--------------------------------------------------------------------------------
/AddPlugin.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | OLD="\"plugins\": \["
4 | 
5 | NEW="\"plugins\": \[\
6 |         \"$1\","
7 | 
8 | sed -i".bak" "s#$OLD#$NEW#g" "./Wikis/$2/tiddlywiki.info"


--------------------------------------------------------------------------------
/MakePlugin.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Author: Jed Carty April 13 2020 (@inmysocks on GitHub.com)
 3 | #
 4 | # This script creates an empty plugin in the Plugins folder
 5 | #
 6 | # Usage: ./MakePlugin.sh PluginName AuthorName
 7 | 
 8 | if [ ! -f ./Author.txt ]; then
 9 |   echo "Run Setup.sh before running this."
10 |   exit 0
11 | fi
12 | 
13 | AUTHOR=$(<./Author.txt)
14 | PLUGINNAME="DemoPlugin"
15 | PLUGINFOLDER=$(<PluginFolder.txt)
16 | 
17 | if [ "$1" ]; then
18 |   PLUGINNAME=$1
19 | fi
20 | 
21 | if [ "$2" ]; then
22 |   AUTHOR=$2
23 | fi
24 | 
25 | if [ -d "$PLUGINFOLDER/$AUTHOR" ]; then
26 |   mkdir "$PLUGINFOLDER/$AUTHOR/$PLUGINNAME"
27 | else
28 |   mkdir "$PLUGINFOLDER/$AUTHOR"
29 |   mkdir "$PLUGINFOLDER/$AUTHOR/$PLUGINNAME"
30 | fi
31 | 
32 | echo "{
33 |   \"title\": \"\$:/plugins/$AUTHOR/$PLUGINNAME\",
34 |   \"description\": \"A plugin description goes here\",
35 |   \"author\": \"$AUTHOR\",
36 |   \"version\": \"0.0.1\",
37 |   \"core-version\": \">=5.1.13\",
38 |   \"source\": \"\",
39 |   \"list\": \"readme\",
40 |   \"plugin-type\": \"plugin\"
41 | }" > "$PLUGINFOLDER/$AUTHOR/$PLUGINNAME/plugin.info"
42 | 
43 | echo "title: \$:/plugins/$AUTHOR/$PLUGINNAME/readme
44 | caption: readme
45 | 
46 | Readme text goes here." > "$PLUGINFOLDER/$AUTHOR/$PLUGINNAME/readme.tid"
47 | 
48 | echo "New empty plugin created in $PLUGINFOLDER/$AUTHOR/$PLUGINNAME."
49 | 
50 | ./MakeWiki.sh "$AUTHOR/$PLUGINNAME" server
51 | 
52 | ./AddPlugin.sh "$AUTHOR/$PLUGINNAME" "$AUTHOR/$PLUGINNAME"


--------------------------------------------------------------------------------
/MakePluginLibrary.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Author: Jed Carty April 13 2020 (@inmysocks on GitHub.com)
 3 | 
 4 | if [ ! -f ./Author.txt ]; then
 5 |   echo "Run Setup.sh before running this."
 6 |   exit 0
 7 | fi
 8 | 
 9 | # You have to change this to match your actual plugin path
10 | export TIDDLYWIKI_PLUGIN_PATH=$(<PluginFolder.txt)
11 | export TIDDLYWIKI_THEME_PATH=$(<ThemeFolder.txt)
12 | export TIDDLYWIKI_LANGUAGE_PATH=$(<LanguageFolder.txt)
13 | 
14 | node ./TiddlyWiki5/tiddlywiki.js ./PluginLibrary --build mylibrary
15 | 


--------------------------------------------------------------------------------
/MakeWiki.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Author: Jed Carty April 13 2020 (@inmysocks on GitHub.com)
 3 | # This script creates a wiki using the given name and edition. If none are
 4 | # given it defaults to the name wiki and the empty edition.
 5 | #
 6 | # Usage: ./MakeWiki.sh someWiki empty
 7 | 
 8 | NAME="wiki"
 9 | EDITION="empty"
10 | 
11 | if [ "$1" ]; then
12 |     NAME=$1
13 | fi
14 | 
15 | if [ "$2" ]; then
16 |     EDITION=$2
17 | fi
18 | 
19 | node ./TiddlyWiki5/tiddlywiki.js "$(pwd)/Wikis/$NAME" --init $EDITION
20 | 
21 | if [ -f "$(pwd)/Wikis/$NAME/tiddlywiki.info" ]; then
22 |     echo "New wiki created in $(pwd)/Wikis/$Name using $EDITION edition"
23 | else
24 |     echo "Error creating wiki. If you make a bug report please include all the output after you ran MakeWiki.sh"
25 | fi
26 | 


--------------------------------------------------------------------------------
/PluginLibrary/tiddlywiki.info:
--------------------------------------------------------------------------------
 1 | {
 2 |     "description": "An Example Custom Plugin Library",
 3 |     "plugins": [
 4 |         "tiddlywiki/pluginlibrary"
 5 |     ],
 6 |     "themes": [],
 7 |     "build": {
 8 |         "library": [
 9 |             "--makelibrary",
10 |             "$:/UpgradeLibrary",
11 |             "--savelibrarytiddlers",
12 |             "$:/UpgradeLibrary",
13 |             "[prefix[$:/]] -[[$:/plugins/tiddlywiki/upgrade]] -[[$:/plugins/tiddlywiki/translators]] -[[$:/plugins/tiddlywiki/pluginlibrary]] -[[$:/plugins/tiddlywiki/jasmine]]",
14 |             "recipes/library/tiddlers/",
15 |             "$:/UpgradeLibrary/List",
16 |             "--savetiddler",
17 |             "$:/UpgradeLibrary/List",
18 |             "recipes/library/tiddlers.json",
19 |             "--rendertiddler",
20 |             "$:/plugins/tiddlywiki/pluginlibrary/library.template.html",
21 |             "index.html",
22 |             "text/plain"
23 |         ],
24 |         "mylibrary": [
25 |             "--makelibrary",
26 |             "$:/UpgradeLibrary",
27 |             "--savelibrarytiddlers",
28 |             "$:/UpgradeLibrary",
29 |             "[prefix[$:/]] -[prefix[$:/plugins/tiddlywiki/]] -[prefix[$:/themes/tiddlywiki/]] -[prefix[$:/languages/]]",
30 |             "recipes/library/tiddlers/",
31 |             "$:/UpgradeLibrary/List",
32 |             "recipes/library/tiddlers.json",
33 |             "--savetiddler",
34 |             "$:/UpgradeLibrary/List",
35 |             "recipes/library/tiddlers.json",
36 |             "--rendertiddler",
37 |             "$:/plugins/tiddlywiki/pluginlibrary/library.template.html",
38 |             "index.html",
39 |             "text/plain"
40 |         ]
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
  1 | # TiddlyWiki5 Plugin Development Example
  2 | 
  3 | This repo is a stripped down version of what I use to create plugins and make a
  4 | plugin library.
  5 | 
  6 | It has a few components:
  7 | 
  8 | 1. its own copy of the TiddlyWiki5 repo, this way you can do anything you want
  9 |   here, including modifying the core, and you won't break anything else.
 10 | 2. A script to start a wiki in a node server.
 11 | 3. A script to create an empty plugin that you can then edit to make whatever
 12 |   you want.
 13 | 4. A script to create new wikis that you can use to test plugins.
 14 | 5. A script that you can use to create a plugin library with the plugins you
 15 |   have created.
 16 | 6. A script to add plugins to the wikis
 17 | 
 18 | If there is a new version of tiddlywiki available run `Setup.sh` again and it
 19 | will ask if you wish to update tiddlywiki or not, press `1` for yes or `2` for
 20 | no.
 21 | 
 22 | ## Setup
 23 | 
 24 | 1. Clone this repo using `git clone --recurse-submodules https://github.com/inmysocks/PluginDevelopment.git`
 25 | 2. Go into the PluginDevelopment folder `cd PluginDevelopment`
 26 | 2. Run `./Setup.sh`
 27 | 
 28 | ## Using this
 29 | 
 30 | ### Making a plugin
 31 | 
 32 | ''Note:'' Making a plugin also makes a wiki that includes the new plugin, so
 33 | you can test the plugin without having to make anything new.
 34 | 
 35 | ```
 36 | ./MakePlugin.sh PluginName
 37 | ```
 38 | 
 39 | To initialise a plugin run the script `MakePlugin.sh`, it will create a plugin
 40 | in the folder `./Plugins/PluginAuthor/PluginName`, where the author name is the
 41 | name given during setup and the plugin name is the name given to the command.
 42 | 
 43 | If for some reason you want to use a different author name for a plugin and
 44 | don't want to change the default name you can give the author name as the
 45 | second argument.
 46 | 
 47 | ```
 48 | ./MakePlugin.sh PluginName DifferentAuthorName
 49 | ```
 50 | 
 51 | If you do this the plugin will be created in the folder `./Plugins/DifferentAuthorName/PluginName`.
 52 | 
 53 | This also creates a wiki that using the server edition that has your plugin as
 54 | a place where you can test and document it. The wiki is located in the folder
 55 | `./Wikis/PluginAuthor/PluginName`, to start the wiki run `./start PluginName`
 56 | and it will start the wiki server on the default port `8080`.
 57 | 
 58 | If you want to use a different port you can give it as the second argument like
 59 | this:
 60 | 
 61 | ```
 62 | ./start PluginAuthor/PluginName 8181
 63 | ```
 64 | 
 65 | where you can change 8181 to whatever port you wish to use.
 66 | 
 67 | Remember that changes made to the plugin will not update in the wiki unless you
 68 | stop the server and restart it.
 69 | 
 70 | ### Making a plugin library
 71 | 
 72 | To make a plugin library use the script `MakePluginLibrary.sh` which will
 73 | create the plugin library in the folder `./PluginLibrary/output`.
 74 | 
 75 | TODO add notes about how to host the plugin library.
 76 | 
 77 | Short version, if you have a webhost that can host static files you can just
 78 | copy the contents of the `PluginLibrary/output` folder into a folder on your
 79 | host and then the url for the library will be whatever the url for that folder
 80 | on your host is.
 81 | 
 82 | TODO add information about how to make a plugin library tiddler
 83 | 
 84 | ### Making wikis
 85 | 
 86 | If you want to make a wiki without a plugin you can use the `./MakeWiki.sh`
 87 | script.
 88 | 
 89 | Typing
 90 | 
 91 | ```
 92 | ./MakeWiki.sh wikiName
 93 | ```
 94 | 
 95 | will make a wiki is the `./Wikis/wikiName` folder using the empty edition.
 96 | 
 97 | If you want to use another edition you can give it as the second argument:
 98 | 
 99 | ```
100 | ./MakeWiki.sh wikiName server
101 | ```
102 | 
103 | will make a wiki called `wikiName` using the `server` edition.
104 | 
105 | # Other Information
106 | 
107 | ## The plugin library tiddlywiki.info file
108 | 
109 | The file `./PluginLibrary/tiddlywiki.info` is a normal tiddlywiki.info file
110 | with the arguments in the build command to create a plugin library.
111 | 
112 | The filter
113 | 
114 | `[prefix[$:/]] -[prefix[$:/plugins/tiddlywiki/]] -[prefix[$:/themes/tiddlywiki/]] -[prefix[$:/languages/]]`
115 | 
116 | on line 29 determines which plugins are added to the plugin library created.
117 | It adds everything other than the core plugins and any languages.
118 | If you want to add languages using this you have to modify this filter to
119 | either allow all languages or add on the language(s) individually.
120 | 


--------------------------------------------------------------------------------
/Setup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Author: Jed Carty April 13 2020 (@inmysocks on GitHub.com)
 3 | #
 4 | # Setup script for tiddlywiki plugin development
 5 | 
 6 | echo "
 7 | Welcome to the setup script!
 8 | 
 9 | Run this script to help setup your development environment for tiddlywiki 5.
10 | If you move your plugin development folder you must re-run this script.
11 | "
12 | 
13 | if [ ! -f ./TiddlyWikiVersion.txt ]; then
14 |   cd TiddlyWiki5
15 |   TAG=$(git describe --tags `git rev-list --tags --max-count=1`)
16 |   cd ..
17 |   echo $TAG > ./TiddlyWikiVersion.txt
18 | fi
19 | 
20 | 
21 | echo "Checking for newer versions of tiddlywiki"
22 | CURRENTTAG=$(<./TiddlyWikiVersion.txt)
23 | cd TiddlyWiki5
24 | NEWESTTAG=$(git ls-remote --tags | grep -o 'refs/tags/v[0-9]*\.[0-9]*\.[0-9]*' | sort -rV | head -n 1 | grep -o '[^\/]*$')
25 | cd ..
26 | if [ ! $CURRENTTAG == $NEWESTTAG ]; then
27 |   echo "You are using version $CURRENTTAG but $NEWESTTAG is available."
28 |   echo "Warning: If you have modified the core this will overwrite your
29 |   changes!!!"
30 |   echo "Do you wish to update to $NEWESTTAG? (enter 1 or 2 for yes or no)"
31 |   select yn in "Yes" "No"; do
32 |     case $yn in
33 |       Yes ) UPDATE="yes"; break;;
34 |       No ) UPDATE=""; break;;
35 |     esac
36 |   done
37 |   if [ $UPDATE ]; then
38 |     cd TiddlyWiki5
39 |     git reset --hard
40 |     git fetch --tags
41 |     git checkout $NEWESTTAG
42 |     cd ..
43 |     echo $NEWESTTAG > ./TiddlyWikiVersion.txt
44 |   fi
45 | else
46 |   echo "You have the newest version, $CURRENTTAG"
47 | fi
48 | 
49 | #echo "Patching tiddlywiki to work with this version of the plugin library
50 | #creator."
51 | #./PatchMakeLibrary.sh
52 | 
53 | echo "
54 | Enter the author name, this will be used as the author name for plugins you
55 | create. It can be changed in the future by reruning this script or editing
56 | Author.txt
57 | "
58 | 
59 | CURRENTNAME="DEFAULTAUTHOR"
60 | CURRENTFOLDER="$(pwd)"
61 | 
62 | if [ -f ./Author.txt ]; then
63 |   CURRENTNAME=$(<./Author.txt)
64 | fi
65 | 
66 | echo "Author Name (press enter to leave as $CURRENTNAME):"
67 | read AUTHORNAME
68 | 
69 | if [ "$AUTHORNAME" ]; then
70 |   echo $AUTHORNAME > Author.txt
71 | fi
72 | 
73 | if [ ! -d ./Plugins ]; then
74 |   mkdir ./Plugins
75 | fi
76 | if [ ! -d ./Themes ]; then
77 |   mkdir ./Themes
78 | fi
79 | if [ ! -d ./Languages ]; then
80 |   mkdir ./Languages
81 | fi
82 | if [ ! -d ./Wikis ]; then
83 |   mkdir ./Wikis
84 | fi
85 | 
86 | echo "$CURRENTFOLDER/Plugins" > ./PluginFolder.txt
87 | echo "$CURRENTFOLDER/Themes" > ./ThemeFolder.txt
88 | echo "$CURRENTFOLDER/Languages" > ./LanguageFolder.txt
89 | 


--------------------------------------------------------------------------------
/UtilityTiddlers/MakeLibrary.tid:
--------------------------------------------------------------------------------
  1 | title: Make Plugin Library
  2 | 
  3 | \define makeHTML(json)
  4 | `
  5 | <!doctype html>
  6 | <html>
  7 | <head>
  8 | <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
  9 | <meta name="application-name" content="TiddlyWiki Plugin Library" />
 10 | <meta name="application-version" content="v0.0.0" />
 11 | <meta name="copyright" content="Copyright 2015 Jeremy Ruston" />
 12 | <link id="faviconLink" rel="shortcut icon" href="favicon.ico">
 13 | <title>Plugin Library</title>
 14 | <script>
 15 | var assetList = $(JSONLISTING)$
 16 | 
 17 | /*\
 18 | title: $:/plugins/tiddlywiki/pluginlibrary/libraryserver.js
 19 | type: application/javascript
 20 | module-type: library
 21 | 
 22 | A simple HTTP-over-window.postMessage implementation of a standard TiddlyWeb-compatible server. It uses real HTTP to load the individual tiddler JSON files.
 23 | 
 24 | \*/
 25 | (function(){
 26 | 
 27 | /*jslint node: true, browser: true */
 28 | /*global $tw: false */
 29 | "use strict";
 30 | 
 31 | // Listen for window messages
 32 | window.addEventListener("message",function listener(event){
 33 | 	console.log("plugin library: Received message from",event.origin);
 34 | 	console.log("plugin library: Message content",event.data);
 35 | 	switch(event.data.verb) {
 36 | 		case "GET":
 37 | 			if(event.data.url === "recipes/library/tiddlers.json") {
 38 | 				// Route for recipes/library/tiddlers.json
 39 | 				event.source.postMessage({
 40 | 					verb: "GET-RESPONSE",
 41 | 					status: "200",
 42 | 					cookies: event.data.cookies,
 43 | 					url: event.data.url,
 44 | 					type: "application/json",
 45 | 					body: JSON.stringify(assetList,null,4)
 46 | 				},"*");
 47 | 			} else if(event.data.url.indexOf("recipes/library/tiddlers/") === 0) {
 48 | 				var url = "recipes/library/tiddlers/" + encodeURIComponent(removePrefix(event.data.url,"recipes/library/tiddlers/"));
 49 | 				// Route for recipes/library/tiddlers/<uri-encoded-tiddler-title>.json
 50 | 				httpGet(url,function(err,responseText) {
 51 | 					if(err) {
 52 | 						event.source.postMessage({
 53 | 							verb: "GET-RESPONSE",
 54 | 							status: "404",
 55 | 							cookies: event.data.cookies,
 56 | 							url: event.data.url,
 57 | 							type: "text/plain",
 58 | 							body: "Not found"
 59 | 						},"*");
 60 | 					} else {
 61 | 						event.source.postMessage({
 62 | 							verb: "GET-RESPONSE",
 63 | 							status: "200",
 64 | 							cookies: event.data.cookies,
 65 | 							url: event.data.url,
 66 | 							type: "application/json",
 67 | 							body: responseText
 68 | 						},"*");
 69 | 					}
 70 | 				});
 71 | 			} else {
 72 | 				event.source.postMessage({
 73 | 					verb: "GET-RESPONSE",
 74 | 					status: "404",
 75 | 					cookies: event.data.cookies,
 76 | 					url: event.data.url,
 77 | 					type: "text/plain",
 78 | 					body: "Not found"
 79 | 				},"*");
 80 | 			}
 81 | 			break;
 82 | 	}
 83 | },false);
 84 | 
 85 | // Helper to remove string prefixes
 86 | function removePrefix(string,prefix) {
 87 | 	if(string.indexOf(prefix) === 0) {
 88 | 		return string.substr(prefix.length);
 89 | 	} else {
 90 | 		return string;
 91 | 	}
 92 | }
 93 | 
 94 | // Helper for HTTP GET
 95 | function httpGet(url,callback) {
 96 | 	var http = new XMLHttpRequest();
 97 | 	http.open("GET",url,true);
 98 | 	http.onreadystatechange = function() {
 99 | 		if(http.readyState == 4 && http.status == 200) {
100 | 			callback(null,http.responseText);
101 | 		}
102 | 	};
103 | 	http.send();
104 | }
105 | 
106 | })();
107 | 
108 | </script>
109 | </head>
110 | <body>
111 | 
112 | <h1>HelloThere</h1>
113 | 
114 | <p>This is the TiddlyWiki plugin library. It is not intended to be opened directly in the browser.</p>
115 | 
116 | <p>See <a href="https://tiddlywiki.com/" target="_blank">https://tiddlywiki.com/</a> for details of how to install plugins.</p>
117 | 
118 | </body>
119 | </html>
120 | `
121 | \end
122 | 
123 | \define oneTiddler()
124 |   <$list
125 |     filter='[<theTiddler>fields[]] -text +[bl[]]'
126 |   >
127 |     <br>
128 |     &nbsp;&nbsp;&nbsp;&nbsp;"<$view field='title' jsencoded/>": "<$view tiddler=<<theTiddler>> field=<<currentTiddler>> format=jsencoded/>",
129 |   </$list>
130 |   <$list
131 |     filter='[<theTiddler>fields[]] -text +[bl[]]'
132 |   >
133 |     <br>
134 |     &nbsp;&nbsp;&nbsp;&nbsp;"<$view field='title' jsencoded/>": "<$view tiddler=<<theTiddler>> field=<<currentTiddler>> format=jsencoded/>"
135 |   </$list>
136 | \end
137 | 
138 | \define jsonListing()
139 | [<br>
140 | <$list
141 |   filter='[subfilter{$:/state/PluginLibrary!!filter}] +[bl[]]'
142 |   variable=theTiddler
143 | >
144 |   &nbsp;&nbsp;{
145 |   <<oneTiddler>>
146 |   <br>
147 |   &nbsp;&nbsp;},
148 |   <br>
149 | </$list>
150 | <$list
151 |   filter='[subfilter{$:/state/PluginLibrary!!filter}] +[last[]]'
152 |   variable=theTiddler
153 | >
154 |   &nbsp;&nbsp;{
155 |   <<oneTiddler>>
156 |   <br>
157 |   &nbsp;&nbsp;}
158 |   <br>
159 | </$list>
160 | ]
161 | \end
162 | 
163 | This packages the plugins returned by this filter into the format needed by a plugin library.
164 | 
165 | The file structure needs to be:
166 | 
167 | *Library Folder
168 | ** recipes
169 | *** library
170 | **** tiddlers
171 | ***** //individual tiddler json files//
172 | **** tiddlers.json
173 | ** index.html
174 | 
175 | filter: <$edit-text tiddler='$:/state/PluginLibrary' field=filter/>
176 | 
177 | 
178 | !! tiddlers.json
179 | 
180 | ''filename:'' tiddlers.json
181 | 
182 | ''contents:''
183 | 
184 | <<jsonListing>>
185 | 
186 | !! Tiddler JSON files:
187 | 
188 | <$list filter={{$:/state/PluginLibrary!!filter}}>
189 | 
190 | ---
191 | ''filename:'' <$view field='title' format='urlencoded'/>.json
192 | 
193 | ''contents:''
194 | 
195 | <$text text=<<jsontiddler>>/>
196 | </$list>
197 | 
198 | ---
199 | ''filename:'' index.html
200 | 
201 | ''contents:''
202 | 
203 | <$wikify name=JSONLISTING text=<<jsonListing>>>
204 | <pre>
205 | <<makeHTML>>
206 | </pre>
207 | </$wikify>


--------------------------------------------------------------------------------
/UtilityTiddlers/MakePlugin.tid:
--------------------------------------------------------------------------------
 1 | title: Make Plugin
 2 | 
 3 | \define plugintext()
 4 | {
 5 | "tiddlers": {<$list filter="[subfilter{$:/state/MakePlugin!!filter}]+[bl[]]">
 6 | "{{{ [<currentTiddler>] +[jsonstringify[]] }}}": <$text text=<<jsontiddler>>/>,</$list><$list filter="[subfilter{$:/state/MakePlugin!!filter}]+[last[]]">
 7 | "{{{ [<currentTiddler>] +[jsonstringify[]] }}}": <$text text=<<jsontiddler>>/></$list>
 8 | }
 9 | }
10 | \end
11 | 
12 | Name:
13 | <$edit-text
14 |   tiddler='$:/state/MakePlugin'
15 |   field='name'
16 |   class='tc-edit-texteditor'
17 |   placeholder='Enter the plugin name here'
18 |   default=''
19 | />
20 | Filter:
21 | <$edit-text
22 |   tiddler='$:/state/MakePlugin'
23 |   field='filter'
24 |   class='tc-edit-texteditor'
25 |   placeholder='Enter a filter to select tiddlers for the plugin'
26 |   default=''
27 | />
28 | Description:
29 | <$edit-text
30 |   tiddler='$:/state/MakePlugin'
31 |   field='description'
32 |   class='tc-edit-texteditor'
33 |   placeholder='Enter a description for the plugin'
34 |   default=''
35 | />
36 | List:
37 | <$edit-text
38 |   tiddler='$:/state/MakePlugin'
39 |   field='list'
40 |   class='tc-edit-texteditor'
41 |   placeholder='This is a list of items shown in tabs in the plugin info'
42 |   default=''
43 | />
44 | Version:
45 | <$edit-text
46 |   tiddler='$:/state/MakePlugin'
47 |   field='version'
48 |   class='tc-edit-texteditor'
49 |   placeholder='Enter the plugin version'
50 |   default=''
51 | />
52 | 
53 | <$button>
54 |   Make Plugin
55 |   <$wikify
56 |     name=pluginText
57 |     text="<<plugintext>>"
58 |   >
59 |     <$action-setfield
60 |       $tiddler={{$:/state/MakePlugin!!name}}
61 |       text=<<pluginText>>
62 |       type='application/json'
63 |       description={{$:/state/MakePlugin!!description}}
64 |       core-version=">=5.0.0"
65 |       dependents=""
66 |       list={{$:/state/MakePlugin!!list}}
67 |       plugin-type="plugin"
68 |       version={{$:/state/MakePlugin!!version}}
69 |     />
70 |   </$wikify>
71 | </$button>


--------------------------------------------------------------------------------
/start.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Author: Jed Carty April 13 2020 (@inmysocks on GitHub.com)
 3 | #
 4 | # This starts a wiki server on a given port, defaulting to 8080
 5 | #
 6 | # Usage: ./start.sh wiki 8888
 7 | 
 8 | if [ ! -f ./PluginFolder.txt ]; then
 9 |   echo "Run Setup.sh before running this."
10 |   exit 0
11 | fi
12 | 
13 | WIKI="wiki"
14 | PORT="8080"
15 | 
16 | if [ $1 ]; then
17 |   WIKI=$1
18 | fi
19 | 
20 | if [ $2 ]; then
21 |   PORT=$2
22 | fi
23 | 
24 | export TIDDLYWIKI_PLUGIN_PATH=$(<PluginFolder.txt)
25 | export TIDDLYWIKI_THEME_PATH=$(<ThemeFolder.txt)
26 | export TIDDLYWIKI_LANGUAGE_PATH=$(<LanguageFolder.txt)
27 | 
28 | node ./TiddlyWiki5/tiddlywiki.js ./Wikis/$WIKI --listen port=$PORT
29 | 


--------------------------------------------------------------------------------