@tiddlywiki/mws 0.0.12 → 0.0.13

package/src/commands/mws-load-archive.ts

@@ -1,281 +0,0 @@
-
-import { Commander, CommandInfo } from "../commander";
-import { TiddlerStore } from "../routes/TiddlerStore";
-import { join, resolve } from "path";
-import { Prisma } from "@prisma/client";
-import { Command as SaveArchiveCommand } from "./mws-save-archive";
-import * as _fsp from "fs/promises";
-import { createStrictAwaitProxy } from "../utils";
-import { PrismaClientKnownRequestError } from "@prisma/client/runtime/library";
-import { existsSync } from "fs";
-const fsp = createStrictAwaitProxy(_fsp);
-
-export const info: CommandInfo = {
-	name: "mws-load-archive",
-	synchronous: true
-};
-export class Command {
-
-	constructor(
-		public params: string[],
-		public commander: Commander,
-		public callback: (err?: any) => void
-	) {
-
-
-	}
-
-	async execute() {
-		if (this.params.length < 1) throw "Missing pathname";
-		const archivePath = this.params[0] as string;
-
-		const index: { version: number } = existsSync(resolve(archivePath, "index.json"))
-			? JSON.parse(await fsp.readFile(resolve(archivePath, "index.json"), "utf8"))
-			: { version: 1 };
-		// this is all the versions in this repo.
-		// the multi-wiki-support branch from the TW5 repo is not supported.
-		switch (index.version) {
-			case 1:
-				await new Archiver1(this.commander).loadArchive(archivePath);
-				break;
-			case 2:
-				await new Archiver2(this.commander).loadArchive(archivePath);
-				break;
-			default:
-				throw new Error(`Unsupported archive version ${index.version}`);
-		}
-
-		this.commander.setupRequired = false;
-
-	}
-
-}
-
-class Archiver {
-	constructor(
-		public commander: Commander,
-	) {
-
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-
-class Archiver1 extends Archiver {
-
-	async loadArchive(archivePath: string) {
-		await this.commander.$transaction(async (prisma) => {
-			// load roles from roles/roles.json
-			const roles = JSON.parse(await fsp.readFile(resolve(archivePath, "roles", "roles.json"), "utf8"));
-			await prisma.roles.createMany({ data: roles });
-			// load users from users/{user_id}.json
-			const userFiles = await fsp.readdir(resolve(archivePath, "users"));
-			const users = await Promise.all(userFiles.map(async (userFile) => {
-				return JSON.parse(await fsp.readFile(resolve(archivePath, "users", userFile), "utf8"));
-			}));
-			await prisma.users.createMany({ data: users });
-			// Iterate the bags
-			const bagNames = await fsp.readdir(resolve(archivePath, "bags"));
-			for (const bagFilename of bagNames) {
-				const stat = await fsp.stat(resolve(archivePath, "bags", bagFilename));
-				if (!stat.isDirectory()) continue;
-				console.log(`Reading bag ${decodeURIComponent(bagFilename)}`);
-				await this.restoreBag(resolve(archivePath, "bags", bagFilename), prisma);
-			}
-			// Iterate the recipes
-			const recipeNames = await fsp.readdir(resolve(archivePath, "recipes"));
-			for (const recipeFilename of recipeNames) {
-				if (!recipeFilename.endsWith(".json")) continue;
-				console.log(`Reading recipe ${decodeURIComponent(recipeFilename)}`);
-				await this.restoreRecipe(resolve(archivePath, "recipes", recipeFilename), prisma);
-			}
-
-		}).catch(e => {
-			if (e instanceof PrismaClientKnownRequestError) {
-				console.log(e.code, e.meta, e.message);
-				throw e.message;
-			} else {
-				throw e;
-			}
-		});
-	}
-	private async restoreRecipe(file: string, prisma: PrismaTxnClient) {
-		type RecipeInfo = Awaited<ReturnType<SaveArchiveCommand["getRecipes"]>>[number];
-		const recipeInfo: RecipeInfo = JSON.parse(await fsp.readFile(file, "utf8"));
-		await prisma.recipes.create({
-			data: {
-				recipe_id: recipeInfo.recipe_id,
-				recipe_name: recipeInfo.recipe_name,
-				description: recipeInfo.description,
-				owner_id: recipeInfo.owner_id,
-				acl: { createMany: { data: recipeInfo.acl } },
-				recipe_bags: {
-					createMany: {
-						data: recipeInfo.recipe_bags.map(e => ({
-							bag_id: e.bag_id,
-							position: e.position,
-							with_acl: e.with_acl,
-						}))
-					}
-				}
-			}
-		});
-	}
-	private async restoreBag(folder: string, prisma: PrismaTxnClient) {
-		type BagInfo = Awaited<ReturnType<SaveArchiveCommand["getBags"]>>[number];
-		const bagInfo: BagInfo = JSON.parse(await fsp.readFile(join(folder, "meta.json"), "utf8"));
-		await prisma.bags.create({
-			data: {
-				bag_id: bagInfo.bag_id,
-				bag_name: bagInfo.bag_name,
-				description: bagInfo.description,
-				owner_id: bagInfo.owner_id,
-				is_plugin: bagInfo.bag_name.startsWith("$:/"),
-				acl: { createMany: { data: bagInfo.acl } },
-			}
-		});
-		type TiddlerData = Awaited<ReturnType<SaveArchiveCommand["getBags"]>>[number]["tiddlers"][number];
-		const tiddlerFiles = await fsp.readdir(join(folder, "tiddlers"));
-		const tiddlers: TiddlerData[] = await Promise.all(tiddlerFiles.map(async (tiddlerFilename) => {
-			if (!tiddlerFilename.endsWith(".json")) return;
-			const value = await fsp.readFile(join(folder, "tiddlers", tiddlerFilename), "utf8");
-			return JSON.parse(value);
-		}));
-		await prisma.tiddlers.createMany({
-			data: tiddlers.flatMap((tiddler): Prisma.TiddlersCreateManyInput => ({
-				bag_id: bagInfo.bag_id,
-				title: tiddler.title,
-				is_deleted: tiddler.is_deleted,
-				attachment_hash: tiddler.attachment_hash,
-				tiddler_id: tiddler.tiddler_id,
-			}))
-		});
-		await prisma.fields.createMany({
-			data: tiddlers.flatMap(({ tiddler_id, fields }) => Object.entries(fields)
-				.map(([field_name, field_value]): Prisma.FieldsCreateManyInput =>
-					({ tiddler_id, field_name, field_value, })
-				)
-			)
-		});
-	}
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-
-class Archiver2 extends Archiver {
-
-	async loadArchive(archivePath: string) {
-		await this.commander.$transaction(async (prisma) => {
-			const roles = JSON.parse(await fsp.readFile(resolve(archivePath, "roles.json"), "utf8"));
-			await prisma.roles.createMany({ data: roles });
-			const users: Awaited<ReturnType<SaveArchiveCommand["getUsers"]>> = JSON.parse(await fsp.readFile(resolve(archivePath, "users.json"), "utf8"));
-			await Promise.all(users.map(e => prisma.users.create({
-				data: ({
-					user_id: e.user_id,
-					email: e.email,
-					password: e.password,
-					username: e.username,
-					created_at: e.created_at,
-					last_login: e.last_login,
-					roles: ({ connect: e.roles.map(e => ({ role_id: e.role_id })) }),
-				} satisfies Prisma.UsersUncheckedCreateInput)
-			})));
-
-			// Iterate the bags
-			const bagNames = await fsp.readdir(resolve(archivePath, "bags"));
-			for (const bagFilename of bagNames) {
-				const stat = await fsp.stat(resolve(archivePath, "bags", bagFilename));
-				if (!stat.isDirectory()) continue;
-				console.log(`Reading bag ${decodeURIComponent(bagFilename)}`);
-				await this.restoreBag(resolve(archivePath, "bags", bagFilename), prisma);
-			}
-			// Iterate the recipes
-			const recipeNames = await fsp.readdir(resolve(archivePath, "recipes"));
-			for (const recipeFilename of recipeNames) {
-				if (!recipeFilename.endsWith(".json")) continue;
-				console.log(`Reading recipe ${decodeURIComponent(recipeFilename)}`);
-				await this.restoreRecipe(resolve(archivePath, "recipes", recipeFilename), prisma);
-			}
-
-		}).catch(e => {
-			if (e instanceof PrismaClientKnownRequestError) {
-				console.log(e.code, e.meta, e.message);
-				throw e.message;
-			} else {
-				throw e;
-			}
-		});
-	}
-	private async restoreRecipe(file: string, prisma: PrismaTxnClient) {
-		type RecipeInfo = Awaited<ReturnType<SaveArchiveCommand["getRecipes"]>>[number];
-		const recipeInfo: RecipeInfo = JSON.parse(await fsp.readFile(file, "utf8"));
-		await prisma.recipes.create({
-			data: {
-				recipe_id: recipeInfo.recipe_id,
-				recipe_name: recipeInfo.recipe_name,
-				description: recipeInfo.description,
-				owner_id: recipeInfo.owner_id,
-				acl: { createMany: { data: recipeInfo.acl } },
-				recipe_bags: {
-					createMany: {
-						data: recipeInfo.recipe_bags.map(e => ({
-							bag_id: e.bag_id,
-							position: e.position,
-							with_acl: e.with_acl,
-						}))
-					}
-				}
-			}
-		});
-	}
-	private async restoreBag(folder: string, prisma: PrismaTxnClient) {
-		type BagInfo = Awaited<ReturnType<SaveArchiveCommand["getBags"]>>[number];
-		const bagInfo: BagInfo = JSON.parse(await fsp.readFile(join(folder, "meta.json"), "utf8"));
-		await prisma.bags.create({
-			data: {
-				bag_id: bagInfo.bag_id,
-				bag_name: bagInfo.bag_name,
-				description: bagInfo.description,
-				owner_id: bagInfo.owner_id,
-				is_plugin: bagInfo.is_plugin,
-				acl: { createMany: { data: bagInfo.acl } },
-			}
-		});
-		type TiddlerData = Awaited<ReturnType<SaveArchiveCommand["getBags"]>>[number]["tiddlers"][number];
-		const tiddlerFiles = await fsp.readdir(join(folder, "tiddlers"));
-		const tiddlers: TiddlerData[] = await Promise.all(tiddlerFiles.map(async (tiddlerFilename) => {
-			if (!tiddlerFilename.endsWith(".json")) return;
-			const value = await fsp.readFile(join(folder, "tiddlers", tiddlerFilename), "utf8");
-			return JSON.parse(value);
-		}));
-		await prisma.tiddlers.createMany({
-			data: tiddlers.flatMap((tiddler): Prisma.TiddlersCreateManyInput => ({
-				bag_id: bagInfo.bag_id,
-				title: tiddler.title,
-				is_deleted: tiddler.is_deleted,
-				attachment_hash: tiddler.attachment_hash,
-				tiddler_id: tiddler.tiddler_id,
-			}))
-		});
-		await prisma.fields.createMany({
-			data: tiddlers.flatMap(({ tiddler_id, fields }) => Object.entries(fields)
-				.map(([field_name, field_value]): Prisma.FieldsCreateManyInput =>
-					({ tiddler_id, field_name, field_value, })
-				)
-			)
-		});
-	}
-}

package/src/commands/mws-load-plugin-bags.ts

@@ -1,151 +0,0 @@
-import { resolve } from "node:path";
-
-import { Commander, CommandInfo } from "../commander";
-import { TiddlerStore } from "../routes/TiddlerStore";
-import { TiddlerFields } from "../routes/services/attachments";
-import { truthy, tryParseJSON } from "../utils";
-import { Prisma, PrismaClient, PrismaPromise } from "@prisma/client";
-
-export const info: CommandInfo = {
-	name: "mws-load-plugin-bags",
-	synchronous: true,
-
-};
-
-
-export class Command {
-
-	get $tw() { return this.commander.$tw; }
-	constructor(
-		public params: string[],
-		public commander: Commander,
-		public callback: (err?: any) => void
-	) {
-
-	}
-	async execute() {
-		console.time(`${info.name} complete`);
-		await loadPluginBags(
-			this.$tw,
-			new TiddlerStore(this.commander, this.commander.engine),
-			this.commander.engine
-		);
-		console.timeEnd(`${info.name} complete`);
-	}
-}
-
-
-async function loadPluginBags($tw: any, store: TiddlerStore, engine: PrismaClient) {
-
-	// Copy plugins
-	function makePluginBagName(type: string, publisher: string | undefined, name: string) {
-		return "$:/" + type + "/" + (publisher ? publisher + "/" : "") + name;
-	}
-	function savePlugin(
-		pluginFields: TiddlerFields,
-		// tiddlers: Record<string, TiddlerFields>,
-		type: string,
-		publisher: string | undefined,
-		name: string
-	) {
-
-		const bagName = makePluginBagName(type, publisher, name) as PrismaField<"Bags", "bag_name">;
-		const description = (pluginFields.description ?? "(no description)") as PrismaField<"Bags", "description">;
-		const is_plugin = true as PrismaField<"Bags", "is_plugin">;
-		// await store.saveBagTiddler(pluginFields, bagName);
-		return [
-			store.upsertBag_PrismaPromise(bagName, description, is_plugin, { allowPrivilegedCharacters: true }),
-			...store.saveBagTiddlerFields_PrismaArray(pluginFields, bagName, null),
-			// ...Object.values(tiddlers).flatMap((fields) => store.saveBagTiddlerFields_PrismaArray(fields, bagName, null))
-		].filter(truthy);
-
-	}
-	function collectPlugins(folder: string, type: string, publisher?: string | undefined) {
-		var pluginFolders = $tw.utils.getSubdirectories(folder) || [];
-		const prismaPromiseArray: PrismaPromise<any>[] = [];
-		for (var p = 0; p < pluginFolders.length; p++) {
-			const pluginFolderName = pluginFolders[p];
-			if ($tw.boot.excludeRegExp.test(pluginFolderName)) continue;
-
-			const pluginFields: TiddlerFields = $tw.loadPluginFolder(resolve(folder, pluginFolderName));
-			if (!pluginFields?.title) continue;
-
-			// const { tiddlers = {} } = tryParseJSON<{
-			// 	tiddlers: Record<string, TiddlerFields>
-			// }>(pluginFields.text) ?? {};
-			// delete pluginFields.text;
-
-			prismaPromiseArray.push(...savePlugin(pluginFields, type, publisher, pluginFolderName));
-
-			// console.log(`Import plugin ${pluginFields.title}`);
-		}
-		prismaPromiseArray.forEach(e => {
-			if (e[Symbol.toStringTag] !== "PrismaPromise") console.log(e)
-		})
-		return prismaPromiseArray;
-	}
-	function collectPublisherPlugins(folder: string, type: string) {
-		var publisherFolders: string[] = $tw.utils.getSubdirectories(folder) || [];
-		return publisherFolders.flatMap((publisherFolderName) => {
-			if ($tw.boot.excludeRegExp.test(publisherFolderName)) return [];
-			return collectPlugins(resolve(folder, publisherFolderName), type, publisherFolderName);
-		});
-	};
-	const plugins = $tw.getLibraryItemSearchPaths($tw.config.pluginsPath, $tw.config.pluginsEnvVar);
-	const themes = $tw.getLibraryItemSearchPaths($tw.config.themesPath, $tw.config.themesEnvVar);
-	const languages = $tw.getLibraryItemSearchPaths($tw.config.languagesPath, $tw.config.languagesEnvVar);
-	const prismaPromiseArray = [
-		...plugins.flatMap((folder: string) => collectPublisherPlugins(folder, "plugins")),
-		...themes.flatMap((folder: string) => collectPublisherPlugins(folder, "themes")),
-		...languages.flatMap((folder: string) => collectPlugins(folder, "languages")),
-	];
-	prismaPromiseArray.forEach(e => {
-		if (e[Symbol.toStringTag] !== "PrismaPromise") {
-			if (Array.isArray(e)) console.log(e.length);
-			else console.log(e);
-		}
-	})
-	await engine.$transaction(prismaPromiseArray);
-
-}
-
-
-
-// // these are the main type definitions for the generator function. 
-// // Modify these if you use a typed sql framework.
-// type YieldInput = Prisma.PrismaPromise<any>;
-// type YieldOutput<Input extends YieldInput> = Awaited<Input>;
-// // this is the generator type
-// type PrismaGenerator<T> = Generator<YieldInput[], T, YieldOutput<YieldInput>[]>;
-
-// const prisma = new PrismaClient();
-// prisma.bagAcl.aggregate
-
-
-// type MapInputToOutput<T extends YieldInput[]> = T extends [
-// 	infer First extends YieldInput,
-// 	...infer Rest extends YieldInput[]
-// ] ? [YieldOutput<First>, ...MapInputToOutput<Rest>] : [];
-
-// /** This just types the yield output according to the input. Make sure you call it with `yield*` */
-// function* Yielder<const I extends YieldInput[]>(...input: I)
-// 	: PrismaGenerator<MapInputToOutput<I>> { return (yield input) as MapInputToOutput<I>; }
-
-// function prismaYielder(prisma: PrismaClient) {
-// 	return function* yielder<const I extends YieldInput[]>(...input: I)
-// 		: PrismaGenerator<MapInputToOutput<I>> { return (yield input) as MapInputToOutput<I>; }
-// }
-
-// // this section is an example usage of the above functions
-
-// function* prismaBatchTransaction(yielder: typeof Yielder): PrismaGenerator<{ titles: string[] }> {
-// 	// yield* is essentially a spread operator for generators 
-// 	// yielder yeilds one value then returns the result.
-// 	// this just gives us a way to type the output of a yield according to the input
-// 	// so if we give it a typed sql query input, it can return a typed result
-
-// 	const [result1] = yield* yielder(prisma.bagAcl.aggregate({}));
-
-// 	return { titles: [] };
-
-// }

package/src/commands/mws-load-tiddlers.ts

@@ -1,37 +0,0 @@
-import { resolve } from "path";
-import { CommandInfo, Commander } from "../commander";
-import { TiddlerStore } from "../routes/TiddlerStore";
-import { SiteConfig } from "../routes/router";
-import { TiddlerFields } from "../routes/services/attachments";
-
-export const info: CommandInfo = {
-	name: "mws-load-tiddlers",
-	synchronous: true
-};
-
-export class Command {
-	get $tw() { return this.commander.$tw; }
-	config: SiteConfig;
-	tiddlersPath: string;
-	bagName: PrismaField<"Bags", "bag_name">;
-	constructor(
-		public params: string[],
-		public commander: Commander,
-		public callback: (err?: any) => void
-	) {
-		this.config = this.commander.siteConfig;
-		this.tiddlersPath = resolve(this.params[0] as string);
-		this.bagName = this.params[1] as PrismaField<"Bags", "bag_name">;
-	}
-	async execute() {
-		if (this.params.length < 2) return "Missing pathname and/or bag name";
-		await this.commander.$transaction(async (prisma) => {
-			const store = new TiddlerStore(this.commander, prisma);
-			var tiddlersFromPath = this.$tw.loadTiddlersFromPath(this.tiddlersPath);
-			//@ts-ignore
-			await store.saveTiddlersFromPath(tiddlersFromPath, this.bagName);
-		});
-		return null;
-
-	}
-}

package/src/commands/mws-load-wiki-folder.ts

@@ -1,124 +0,0 @@
-/*\
-title: $:/plugins/tiddlywiki/multiwikiserver/commands/mws-load-wiki-folder.js
-type: application/javascript
-module-type: command
-
-Command to create and load a bag for the specified core editions
-
---mws-load-wiki-folder <path> <bag-name> <bag-description> <recipe-name> <recipe-description>
-
-\*/
-
-
-import { resolve } from "path";
-import { Commander, CommandInfo } from "../commander";
-import { TiddlerStore } from "../routes/TiddlerStore";
-import { TiddlerFields } from "../routes/services/attachments";
-import { Prisma, PrismaClient } from "@prisma/client";
-
-export const info: CommandInfo = {
-	name: "mws-load-wiki-folder",
-	synchronous: true
-};
-// tiddlywiki --load ./mywiki.html --savewikifolder ./mywikifolder
-export class Command {
-	constructor(
-		public params: string[],
-		public commander: Commander,
-		public callback: (err?: any) => void
-	) {
-
-	}
-	async execute() {
-
-		// Check parameters
-		if (this.params.length < 5) {
-			return "Missing parameters for --mws-load-wiki-folder command";
-		}
-
-		await this.commander.engine.$transaction(loadWikiFolder({
-			wikiPath: this.params[0] as string,
-			bagName: this.params[1] as PrismaField<"Bags", "bag_name">,
-			bagDescription: this.params[2] as PrismaField<"Bags", "description">,
-			recipeName: this.params[3] as PrismaField<"Recipes", "recipe_name">,
-			recipeDescription: this.params[4] as PrismaField<"Recipes", "description">,
-			store: new TiddlerStore(this.commander, this.commander.engine),
-			$tw: this.commander.$tw
-		}));
-		console.log(info.name, "complete:", this.params[0])
-		return null;
-	}
-}
-
-
-// Function to convert a plugin name to a bag name
-function makePluginBagName(type: string, publisher: string | undefined, name: string) {
-	return "$:/" + type + "/" + (publisher ? publisher + "/" : "") + name;
-}
-
-// Copy TiddlyWiki core editions
-function loadWikiFolder({ $tw, store, ...options }: {
-	wikiPath: string,
-	bagName: PrismaField<"Bags", "bag_name">,
-	bagDescription: PrismaField<"Bags", "description">,
-	recipeName: PrismaField<"Recipes", "recipe_name">,
-	recipeDescription: PrismaField<"Recipes", "description">,
-	store: TiddlerStore,
-	$tw: any
-}) {
-	const path = require("path"),
-		fs = require("fs");
-	// Read the tiddlywiki.info file
-	const wikiInfoPath = path.resolve(options.wikiPath, $tw.config.wikiInfo);
-	let wikiInfo;
-	if (fs.existsSync(wikiInfoPath)) {
-		wikiInfo = $tw.utils.parseJSONSafe(fs.readFileSync(wikiInfoPath, "utf8"), function () { return null; });
-	}
-	if (!wikiInfo) return [];
-	// Add plugins to the recipe list
-	const recipeList = [];
-	const processPlugins = function (type: string, plugins: string[]) {
-		$tw.utils.each(plugins, function (pluginName: string) {
-			const parts = pluginName.split("/");
-			let publisher, name;
-			if (parts.length === 2) {
-				publisher = parts[0];
-				name = parts[1];
-			} else {
-				name = parts[0];
-			}
-			recipeList.push({ bag_name: makePluginBagName(type, publisher, name as string), with_acl: false });
-		});
-	};
-	processPlugins("plugins", wikiInfo.plugins);
-	processPlugins("themes", wikiInfo.themes);
-	processPlugins("languages", wikiInfo.languages);
-	// Create the recipe
-	recipeList.push({
-		bag_name: options.bagName,
-		with_acl: true as PrismaField<"Recipe_bags", "with_acl">,
-	});
-	recipeList.reverse()
-
-
-	const tiddler_files_path = path.resolve(options.wikiPath, $tw.config.wikiTiddlersSubDir)
-	const tiddlersFromPath: TiddlerInfo[] = $tw.loadTiddlersFromPath(
-		resolve($tw.boot.corePath, $tw.config.editionsPath, tiddler_files_path)
-	);
-
-	const is_plugin = false as PrismaField<"Bags", "is_plugin">;
-	return [
-		// create the bag
-		store.upsertBag_PrismaPromise(options.bagName, options.bagDescription, is_plugin),
-		// create the recipe and recipe_bags entries
-		...store.upsertRecipe_PrismaArray(
-			options.recipeName,
-			options.recipeDescription,
-			recipeList,
-		),
-		// save the tiddlers (this will skip attachments)
-		...store.saveTiddlersFromPath_PrismaArray(tiddlersFromPath, options.bagName)
-	];
-
-}
-interface TiddlerInfo { tiddlers: TiddlerFields[], filepath: string, type: string, hasMetaFile: boolean }

package/src/commands/mws-render-tiddlywiki5.ts

@@ -1,55 +0,0 @@
-/*\
-title: $:/plugins/tiddlywiki/multiwikiserver/commands/mws-render-tiddler.js
-type: application/javascript
-module-type: command
-
-Command to create and load a bag for the specified core editions
-
-
-
-\*/
-
-
-import { resolve } from "node:path";
-import { Commander, CommandInfo } from "../commander";
-
-const { writeFileSync } = require("fs");
-
-export const info: CommandInfo = {
-  name: "mws-render-tiddlywiki5",
-  synchronous: true
-};
-
-export class Command {
-
-  constructor(
-    public params: string[], 
-    public commander: Commander, 
-    public callback: (err?: any) => void
-  ) {
-
-  }
-  async execute() {
-
-    const result = this.commander.$tw.wiki.renderTiddler("text/plain", "$:/core/templates/tiddlywiki5.html", {
-      variables: {
-        saveTiddlerFilter: `
-          $:/boot/boot.css
-          $:/boot/boot.js
-          $:/boot/bootprefix.js
-          $:/core
-          $:/library/sjcl.js
-          $:/plugins/tiddlywiki/tiddlyweb
-          $:/plugins/tiddlywiki/multiwikiclient
-          $:/themes/tiddlywiki/snowwhite
-          $:/themes/tiddlywiki/vanilla
-        `
-      }
-    });
-
-    const filepath = resolve(this.commander.wikiPath, "tiddlywiki5.html")
-
-    writeFileSync(filepath, result);
-  }
-};
-