@powerhousedao/shared 6.0.0-dev.104 → 6.0.0-dev.106

package/dist/document-drive/index.js

@@ -0,0 +1,956 @@
+import { BaseDocumentHeaderSchema, BaseDocumentStateSchema, baseCreateDocument, baseLoadFromInput, baseSaveToFileHandle, createAction, createBaseState, createReducer, createState as createState$1, defaultBaseState, generateId, isDocumentAction } from "../document-model/index.js";
+import { z } from "zod";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region document-drive/constants.ts
+const driveDocumentFileExtension = "phdd";
+//#endregion
+//#region document-drive/gen/schema/zod.ts
+const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
+const definedNonNullAnySchema = z.any().refine((v) => isDefinedNonNullAny(v));
+const TransmitterTypeSchema = z.enum([
+	"Internal",
+	"MatrixConnect",
+	"PullResponder",
+	"RESTWebhook",
+	"SecureConnect",
+	"SwitchboardPush"
+]);
+const TriggerTypeSchema = z.enum(["PullResponder"]);
+function AddFileInputSchema() {
+	return z.object({
+		documentType: z.string(),
+		id: z.string(),
+		name: z.string(),
+		parentFolder: z.string().nullish()
+	});
+}
+function AddFolderInputSchema() {
+	return z.object({
+		id: z.string(),
+		name: z.string(),
+		parentFolder: z.string().nullish()
+	});
+}
+function AddListenerInputSchema() {
+	return z.object({ listener: ListenerInputSchema() });
+}
+function AddTriggerInputSchema() {
+	return z.object({ trigger: TriggerInputSchema() });
+}
+function CopyNodeInputSchema() {
+	return z.object({
+		srcId: z.string(),
+		targetId: z.string(),
+		targetName: z.string().nullish(),
+		targetParentFolder: z.string().nullish()
+	});
+}
+function DeleteNodeInputSchema() {
+	return z.object({ id: z.string() });
+}
+function DocumentDriveLocalStateSchema() {
+	return z.object({
+		__typename: z.literal("DocumentDriveLocalState").optional(),
+		availableOffline: z.boolean(),
+		listeners: z.array(ListenerSchema()),
+		sharingType: z.string().nullable(),
+		triggers: z.array(TriggerSchema())
+	});
+}
+function DocumentDriveStateSchema() {
+	return z.object({
+		__typename: z.literal("DocumentDriveState").optional(),
+		icon: z.string().nullable(),
+		name: z.string(),
+		nodes: z.array(NodeSchema())
+	});
+}
+function FileNodeSchema() {
+	return z.object({
+		__typename: z.literal("FileNode").optional(),
+		documentType: z.string(),
+		id: z.string(),
+		kind: z.string(),
+		name: z.string(),
+		parentFolder: z.string().nullable()
+	});
+}
+function FolderNodeSchema() {
+	return z.object({
+		__typename: z.literal("FolderNode").optional(),
+		id: z.string(),
+		kind: z.string(),
+		name: z.string(),
+		parentFolder: z.string().nullable()
+	});
+}
+function ListenerSchema() {
+	return z.object({
+		__typename: z.literal("Listener").optional(),
+		block: z.boolean(),
+		callInfo: ListenerCallInfoSchema().nullable(),
+		filter: ListenerFilterSchema(),
+		label: z.string().nullable(),
+		listenerId: z.string(),
+		system: z.boolean()
+	});
+}
+function ListenerInputSchema() {
+	return z.object({
+		block: z.boolean(),
+		callInfo: ListenerCallInfoInputSchema().nullish(),
+		filter: ListenerFilterInputSchema(),
+		label: z.string().nullish(),
+		listenerId: z.string(),
+		system: z.boolean()
+	});
+}
+function ListenerCallInfoSchema() {
+	return z.object({
+		__typename: z.literal("ListenerCallInfo").optional(),
+		data: z.string().nullable(),
+		name: z.string().nullable(),
+		transmitterType: TransmitterTypeSchema.nullable()
+	});
+}
+function ListenerCallInfoInputSchema() {
+	return z.object({
+		data: z.string().nullish(),
+		name: z.string().nullish(),
+		transmitterType: TransmitterTypeSchema.nullish()
+	});
+}
+function ListenerFilterSchema() {
+	return z.object({
+		__typename: z.literal("ListenerFilter").optional(),
+		branch: z.array(z.string()).nullable(),
+		documentId: z.array(z.string()).nullable(),
+		documentType: z.array(z.string()),
+		scope: z.array(z.string()).nullable()
+	});
+}
+function ListenerFilterInputSchema() {
+	return z.object({
+		branch: z.array(z.string()).nullish(),
+		documentId: z.array(z.string()).nullish(),
+		documentType: z.array(z.string()).nullish(),
+		scope: z.array(z.string()).nullish()
+	});
+}
+function MoveNodeInputSchema() {
+	return z.object({
+		srcFolder: z.string(),
+		targetParentFolder: z.string().nullish()
+	});
+}
+function NodeSchema() {
+	return z.union([FileNodeSchema(), FolderNodeSchema()]);
+}
+function PullResponderTriggerDataSchema() {
+	return z.object({
+		__typename: z.literal("PullResponderTriggerData").optional(),
+		interval: z.string(),
+		listenerId: z.string(),
+		url: z.string()
+	});
+}
+function PullResponderTriggerDataInputSchema() {
+	return z.object({
+		interval: z.string(),
+		listenerId: z.string(),
+		url: z.string()
+	});
+}
+function RemoveListenerInputSchema() {
+	return z.object({ listenerId: z.string() });
+}
+function RemoveTriggerInputSchema() {
+	return z.object({ triggerId: z.string() });
+}
+function SetAvailableOfflineInputSchema() {
+	return z.object({ availableOffline: z.boolean() });
+}
+function SetDriveIconInputSchema() {
+	return z.object({ icon: z.string() });
+}
+function SetDriveNameInputSchema() {
+	return z.object({ name: z.string() });
+}
+function SetSharingTypeInputSchema() {
+	return z.object({ type: z.string() });
+}
+function TriggerSchema() {
+	return z.object({
+		__typename: z.literal("Trigger").optional(),
+		data: TriggerDataSchema().nullable(),
+		id: z.string(),
+		type: TriggerTypeSchema
+	});
+}
+function TriggerInputSchema() {
+	return z.object({
+		data: PullResponderTriggerDataInputSchema().nullish(),
+		id: z.string(),
+		type: TriggerTypeSchema
+	});
+}
+function TriggerDataSchema() {
+	return PullResponderTriggerDataSchema();
+}
+function UpdateFileInputSchema() {
+	return z.object({
+		documentType: z.string().nullish(),
+		id: z.string(),
+		name: z.string().nullish(),
+		parentFolder: z.string().nullish()
+	});
+}
+function UpdateNodeInputSchema() {
+	return z.object({
+		id: z.string(),
+		name: z.string().nullish(),
+		parentFolder: z.string().nullish()
+	});
+}
+//#endregion
+//#region document-drive/gen/node/creators.ts
+function addFile(input) {
+	if (input && typeof input === "object" && "synchronizationUnits" in input) return createAction("ADD_FILE", { ...input }, void 0, void 0, "global");
+	return createAction("ADD_FILE", { ...input }, void 0, AddFileInputSchema, "global");
+}
+const addFolder = (input) => createAction("ADD_FOLDER", { ...input }, void 0, AddFolderInputSchema, "global");
+const deleteNode = (input) => createAction("DELETE_NODE", { ...input }, void 0, DeleteNodeInputSchema, "global");
+const updateFile = (input) => createAction("UPDATE_FILE", { ...input }, void 0, UpdateFileInputSchema, "global");
+const updateNode = (input) => createAction("UPDATE_NODE", { ...input }, void 0, UpdateNodeInputSchema, "global");
+const copyNode = (input) => createAction("COPY_NODE", { ...input }, void 0, CopyNodeInputSchema, "global");
+const moveNode = (input) => createAction("MOVE_NODE", { ...input }, void 0, MoveNodeInputSchema, "global");
+//#endregion
+//#region document-drive/gen/drive/creators.ts
+const setDriveName = (input) => createAction("SET_DRIVE_NAME", { ...input }, void 0, SetDriveNameInputSchema, "global");
+const setDriveIcon = (input) => createAction("SET_DRIVE_ICON", { ...input }, void 0, SetDriveIconInputSchema, "global");
+const setSharingType = (input) => createAction("SET_SHARING_TYPE", { ...input }, void 0, SetSharingTypeInputSchema, "local");
+const setAvailableOffline = (input) => createAction("SET_AVAILABLE_OFFLINE", { ...input }, void 0, SetAvailableOfflineInputSchema, "local");
+const addListener = (input) => createAction("ADD_LISTENER", { ...input }, void 0, AddListenerInputSchema, "local");
+const removeListener = (input) => createAction("REMOVE_LISTENER", { ...input }, void 0, RemoveListenerInputSchema, "local");
+const addTrigger = (input) => createAction("ADD_TRIGGER", { ...input }, void 0, AddTriggerInputSchema, "local");
+const removeTrigger = (input) => createAction("REMOVE_TRIGGER", { ...input }, void 0, RemoveTriggerInputSchema, "local");
+//#endregion
+//#region document-drive/gen/creators.ts
+var creators_exports = /* @__PURE__ */ __exportAll({
+	addFile: () => addFile,
+	addFolder: () => addFolder,
+	addListener: () => addListener,
+	addTrigger: () => addTrigger,
+	copyNode: () => copyNode,
+	deleteNode: () => deleteNode,
+	moveNode: () => moveNode,
+	removeListener: () => removeListener,
+	removeTrigger: () => removeTrigger,
+	setAvailableOffline: () => setAvailableOffline,
+	setDriveIcon: () => setDriveIcon,
+	setDriveName: () => setDriveName,
+	setSharingType: () => setSharingType,
+	updateFile: () => updateFile,
+	updateNode: () => updateNode
+});
+//#endregion
+//#region document-drive/gen/document-model.ts
+const driveDocumentModel = {
+	id: "powerhouse/document-drive",
+	name: "DocumentDrive",
+	extension: "phdd",
+	description: "",
+	author: {
+		name: "Powerhouse Inc",
+		website: "https://www.powerhouse.inc/"
+	},
+	specifications: [{
+		version: 1,
+		changeLog: [],
+		state: {
+			global: {
+				schema: "type FolderNode {\n    id: String!\n    name: String!\n    kind: String!\n    parentFolder: String\n}\n\ntype FileNode {\n    id: String!\n    name: String!\n    kind: String!\n    documentType: String!\n    parentFolder: String\n}\n\nunion Node = FolderNode | FileNode\n\ntype DocumentDriveState {\n    name: String!\n    nodes: [Node!]!\n    icon: String\n}",
+				initialValue: "\"{\\\"name\\\":\\\"\\\",\\\"nodes\\\":[],\\\"icon\\\":null}\"",
+				examples: []
+			},
+			local: {
+				schema: "type ListenerFilter {\n    documentType: [String!]!\n    documentId: [ID!]\n    scope: [String!]\n    branch: [String!]\n}\n\nenum TransmitterType {\n    Internal,\n    SwitchboardPush,\n    PullResponder,\n    SecureConnect, \n    MatrixConnect,\n    RESTWebhook\n}\n\ntype ListenerCallInfo {\n    transmitterType: TransmitterType\n    name: String\n    data: String\n}\n\ntype Listener {\n    listenerId: ID!\n    label: String\n    block: Boolean!\n    system: Boolean!\n    filter: ListenerFilter!\n    callInfo: ListenerCallInfo\n}\n\nenum TriggerType {\n    PullResponder\n}\n\ntype PullResponderTriggerData {\n    listenerId: ID!\n    url: String!\n    interval: String!\n}\n\nunion TriggerData = PullResponderTriggerData\n\ntype Trigger {\n    id: ID!\n    type: TriggerType!\n    data: TriggerData\n}\n\ntype DocumentDriveLocalState{\n    sharingType: String\n    listeners: [Listener!]!\n    triggers: [Trigger!]!\n    availableOffline: Boolean!\n}",
+				initialValue: "\"{ \\\"listeners\\\": [], \\\"triggers\\\": [], \\\"sharingType\\\": \\\"private\\\", \\\"availableOffline\\\": false}\"",
+				examples: []
+			}
+		},
+		modules: [{
+			id: "GRzuvv78tBvmB6ciitokLfonNHA=",
+			name: "Node",
+			description: "",
+			operations: [
+				{
+					id: "7xiTdxonc9yEASR8sfV/KnbSV10=",
+					name: "ADD_FILE",
+					description: "",
+					schema: "input AddFileInput {\n    id: ID!\n    name: String!\n    documentType: String!\n    parentFolder: ID\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "4lzNMMKKdIAtEU6i12xLgi9hp+U=",
+					name: "ADD_FOLDER",
+					description: "",
+					schema: "input AddFolderInput {\n    id: ID!\n    name: String!\n    parentFolder: ID\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "53jH2/3TWTTcgCJiv2C+BmuC6i0=",
+					name: "DELETE_NODE",
+					description: "",
+					schema: "input DeleteNodeInput {\n    id: ID!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "pNn+Y1/HVq/GNMk7t0u3g3gtMLE=",
+					name: "UPDATE_FILE",
+					description: "",
+					schema: "input UpdateFileInput {\n    id: ID!\n    parentFolder: ID\n    name: String\n    documentType: String\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "P0x1M8Mnt+Q/+9nggkwgVbfybsc=",
+					name: "UPDATE_NODE",
+					description: "",
+					schema: "input UpdateNodeInput {\n    id: ID!\n    parentFolder: ID\n    name: String\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "vnQ7OB5b3wGLgjhbgJqAIpA+JLE=",
+					name: "COPY_NODE",
+					description: "",
+					schema: "input CopyNodeInput {\n    srcId: ID!\n    targetId: ID!\n    targetName: String\n    targetParentFolder: ID\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "VNyiD/sNGzk6k9A1Qe7s8dmrJxA=",
+					name: "MOVE_NODE",
+					description: "",
+					schema: "input MoveNodeInput {\n    srcFolder: ID!\n    targetParentFolder: ID\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				}
+			]
+		}, {
+			id: "0dHwHlxOM9x0vMZ+gLnKxf2qTEo=",
+			name: "Drive",
+			description: "",
+			operations: [
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z1dsU=",
+					name: "SET_DRIVE_NAME",
+					description: "",
+					schema: "input SetDriveNameInput {\n    name: String!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z30dsU=",
+					name: "SET_DRIVE_ICON",
+					description: "",
+					schema: "input SetDriveIconInput {\n    icon: String!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z2dsU=",
+					name: "SET_SHARING_TYPE",
+					description: "",
+					schema: "input SetSharingTypeInput {\n    type: String!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z3dsU=",
+					name: "SET_AVAILABLE_OFFLINE",
+					description: "",
+					schema: "input SetAvailableOfflineInput {\n    availableOffline: Boolean!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z9dsU=",
+					name: "ADD_LISTENER",
+					description: "",
+					schema: "input ListenerFilterInput {\n    documentType: [String!]\n    documentId: [ID!]\n    scope: [String!]\n    branch: [String!]\n}\n\ninput ListenerCallInfoInput {\n    transmitterType: TransmitterType\n    name: String\n    data: String\n}\n\ninput ListenerInput {\n    listenerId: ID!\n    label: String\n    block: Boolean!\n    system: Boolean!\n    filter: ListenerFilterInput!\n    callInfo: ListenerCallInfoInput\n}\n\ninput AddListenerInput {\n    listener: ListenerInput!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z10dsU=",
+					name: "REMOVE_LISTENER",
+					description: "",
+					schema: "input RemoveListenerInput {\n    listenerId: String!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z20dsU=",
+					name: "ADD_TRIGGER",
+					description: "",
+					schema: "input PullResponderTriggerDataInput {\n    listenerId: ID!\n    url: String!\n    interval: String!\n}\n\ninput TriggerInput {\n    id: ID!\n    type: TriggerType!\n    data: PullResponderTriggerDataInput\n}\n\ninput AddTriggerInput {\n    trigger: TriggerInput!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "qGCiPGpTt/cyz3HzyrBn92z30dsU=",
+					name: "REMOVE_TRIGGER",
+					description: "",
+					schema: "input RemoveTriggerInput {\n    triggerId: String!\n}",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				}
+			]
+		}]
+	}]
+};
+//#endregion
+//#region document-drive/gen/document-type.ts
+const driveDocumentType = "powerhouse/document-drive";
+//#endregion
+//#region document-drive/gen/ph-factories.ts
+/**
+* Factory methods for creating DocumentDriveDocument instances
+*/
+function defaultGlobalState() {
+	return {
+		icon: null,
+		name: "",
+		nodes: []
+	};
+}
+function defaultLocalState() {
+	return {
+		availableOffline: false,
+		listeners: [],
+		sharingType: null,
+		triggers: []
+	};
+}
+function defaultPHState() {
+	return {
+		...defaultBaseState(),
+		global: defaultGlobalState(),
+		local: defaultLocalState()
+	};
+}
+function createGlobalState(state) {
+	return {
+		...defaultGlobalState(),
+		...state || {}
+	};
+}
+function createLocalState(state) {
+	return {
+		...defaultLocalState(),
+		...state || {}
+	};
+}
+function createState(baseState, globalState, localState) {
+	return {
+		...createBaseState(baseState?.auth, baseState?.document),
+		global: createGlobalState(globalState),
+		local: createLocalState(localState)
+	};
+}
+//#endregion
+//#region document-drive/src/reducers/drive.ts
+const driveReducer = {
+	setDriveNameOperation(state, action, dispatch) {
+		state.name = action.input.name;
+	},
+	setDriveIconOperation(state, action, dispatch) {
+		state.icon = action.input.icon;
+	},
+	setSharingTypeOperation(state, action, dispatch) {
+		state.sharingType = action.input.type;
+	},
+	setAvailableOfflineOperation(state, action, dispatch) {
+		state.availableOffline = action.input.availableOffline;
+	},
+	addListenerOperation(state, action, dispatch) {
+		const { listener: input } = action.input;
+		if (state.listeners.find((l) => l.listenerId === input.listenerId)) throw new Error(`A listener with Id: ${input.listenerId} already exists`);
+		const listener = {
+			listenerId: input.listenerId,
+			label: input.label ?? null,
+			block: input.block,
+			system: input.system,
+			filter: {
+				documentType: input.filter.documentType ?? null,
+				documentId: input.filter.documentId ?? null,
+				scope: input.filter.scope ?? null,
+				branch: input.filter.branch ?? null
+			},
+			callInfo: input.callInfo ? {
+				transmitterType: input.callInfo.transmitterType ?? null,
+				name: input.callInfo.name ?? null,
+				data: input.callInfo.data ?? null
+			} : null
+		};
+		state.listeners.push(listener);
+	},
+	removeListenerOperation(state, action, dispatch) {
+		state.listeners = state.listeners.filter((listener) => listener.listenerId !== action.input.listenerId);
+	},
+	addTriggerOperation(state, action, dispatch) {
+		const { trigger: input } = action.input;
+		if (state.triggers.find((t) => t.id === input.id)) throw new Error(`A trigger with Id: ${input.id} already exists`);
+		const trigger = {
+			id: input.id,
+			type: input.type,
+			data: input.data ? { ...input.data } : null
+		};
+		state.triggers.push(trigger);
+	},
+	removeTriggerOperation(state, action, dispatch) {
+		state.triggers = state.triggers.filter((trigger) => trigger.id !== action.input.triggerId);
+	}
+};
+//#endregion
+//#region document-drive/src/utils.ts
+function isFileNode(node) {
+	return node.kind === "file";
+}
+function isFolderNode(node) {
+	return node.kind === "folder";
+}
+function getAncestors(node, allNodes) {
+	if (!node.parentFolder) return [];
+	else {
+		const parentNode = allNodes.find((_node) => _node.id === node.parentFolder);
+		if (!parentNode) throw new Error(`Parent node with id ${node.parentFolder} not found`);
+		return [parentNode, ...getAncestors(parentNode, allNodes)];
+	}
+}
+function getDescendants(node, allNodes) {
+	const children = allNodes.filter((_node) => _node.parentFolder === node.id);
+	const descendants = children.map((child) => getDescendants(child, allNodes));
+	return [...children, ...descendants.flat()];
+}
+/**
+* Generates a copy of nodes based on the provided source and target information.
+* @param src - The source information for generating the copy.
+* @param idGenerator - The function used to generate new IDs for the copied nodes.
+* @param nodes - The array of nodes to copy from.
+* @returns An array of copied nodes with updated IDs and parent folders.
+* @throws Error if the root node with the specified ID is not found.
+*/
+function generateNodesCopy(src, idGenerator, nodes) {
+	const rootNode = nodes.find((node) => node.id === src.srcId);
+	if (!rootNode) throw new Error(`Node with id ${src.srcId} not found`);
+	const nodesToCopy = [{
+		...rootNode,
+		name: src.targetName || rootNode.name,
+		parentFolder: src.targetParentFolder || null
+	}, ...getDescendants(rootNode, nodes)];
+	const ids = {};
+	if (src.targetParentFolder) ids[src.targetParentFolder] = src.targetParentFolder;
+	const getNewNodeId = (node) => {
+		let newId = ids[node.id];
+		if (!newId) {
+			const oldId = node.id;
+			newId = idGenerator(node);
+			ids[oldId] = newId;
+		}
+		return newId;
+	};
+	return nodesToCopy.map((node) => ({
+		srcId: node.id,
+		targetId: getNewNodeId(node),
+		targetName: node.name,
+		targetParentFolder: node.parentFolder ? ids[node.parentFolder] : null
+	}));
+}
+function getNextCopyNumber(files, baseFilename) {
+	let maxNumber = 0;
+	const regex = new RegExp(`^${escapeRegExp(baseFilename)} \\(copy\\)(?: (\\d+))?$`);
+	for (const file of files) {
+		const match = file.match(regex);
+		if (match) {
+			const number = match[1] ? parseInt(match[1], 10) : 1;
+			if (number > maxNumber) maxNumber = number;
+		}
+	}
+	return maxNumber + 1;
+}
+function escapeRegExp(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function handleTargetNameCollisions(params) {
+	const { nodes, targetParentFolder, srcName } = params;
+	const targetNodeChildrenNames = nodes.filter((node) => targetParentFolder === "" ? node.parentFolder === null : node.parentFolder === targetParentFolder).map((node) => node.name);
+	return targetNodeChildrenNames.includes(srcName) ? `${srcName} (copy) ${getNextCopyNumber(targetNodeChildrenNames, srcName)}` : srcName;
+}
+const isValidName = (name) => {
+	return /^[a-zA-Z0-9-_.\s()]+$/.test(name);
+};
+//#endregion
+//#region document-drive/src/reducers/node.ts
+const nodeReducer = {
+	addFileOperation(state, action, dispatch) {
+		if (state.nodes.find((node) => node.id === action.input.id)) throw new Error(`Node with id ${action.input.id} already exists!`);
+		if (!isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must be valid URL characters.`);
+		const name = handleTargetNameCollisions({
+			nodes: state.nodes,
+			srcName: action.input.name,
+			targetParentFolder: action.input.parentFolder || null
+		});
+		const fileNode = {
+			id: action.input.id,
+			name,
+			kind: "file",
+			parentFolder: action.input.parentFolder ?? null,
+			documentType: action.input.documentType
+		};
+		state.nodes.push(fileNode);
+		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		dispatch?.({
+			type: "CREATE_CHILD_DOCUMENT",
+			input: {
+				id: action.input.id,
+				documentType: action.input.documentType
+			}
+		});
+	},
+	addFolderOperation(state, action) {
+		if (state.nodes.find((node) => node.id === action.input.id)) throw new Error(`Node with id ${action.input.id} already exists!`);
+		if (!isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must be valid URL characters.`);
+		const name = handleTargetNameCollisions({
+			nodes: state.nodes,
+			srcName: action.input.name,
+			targetParentFolder: action.input.parentFolder || null
+		});
+		state.nodes.push({
+			...action.input,
+			name,
+			kind: "folder",
+			parentFolder: action.input.parentFolder ?? null
+		});
+		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+	},
+	deleteNodeOperation(state, action, dispatch) {
+		const node = state.nodes.find((node) => node.id === action.input.id);
+		if (!node) throw new Error(`Node with id ${action.input.id} not found`);
+		const descendants = getDescendants(node, state.nodes);
+		state.nodes = state.nodes.filter((node) => node.id !== action.input.id && !descendants.find((descendant) => descendant.id === node.id));
+		[node, ...descendants].filter((node) => isFileNode(node)).forEach((node) => {
+			dispatch?.({
+				type: "DELETE_CHILD_DOCUMENT",
+				input: { id: node.id }
+			});
+		});
+	},
+	updateFileOperation(state, action) {
+		if (action.input.name && !isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must be valid URL characters.`);
+		state.nodes = state.nodes.map((node) => node.id === action.input.id ? {
+			...node,
+			name: handleTargetNameCollisions({
+				nodes: state.nodes,
+				srcName: action.input.name ?? node.name,
+				targetParentFolder: action.input.parentFolder || null
+			}),
+			documentType: action.input.documentType ?? node.documentType
+		} : node);
+		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+	},
+	updateNodeOperation(state, action) {
+		if (action.input.name && !isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must be valid URL characters.`);
+		state.nodes = state.nodes.map((node) => node.id === action.input.id ? {
+			...node,
+			name: handleTargetNameCollisions({
+				nodes: state.nodes,
+				srcName: action.input.name ?? node.name,
+				targetParentFolder: action.input.parentFolder || null
+			}),
+			parentFolder: action.input.parentFolder === null ? null : node.parentFolder
+		} : node);
+		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+	},
+	copyNodeOperation(state, action, dispatch) {
+		const node = state.nodes.find((node) => node.id === action.input.srcId);
+		if (!node) throw new Error(`Node with id ${action.input.srcId} not found`);
+		if (state.nodes.find((node) => node.id === action.input.targetId)) throw new Error(`Node with id ${action.input.targetId} already exists`);
+		const name = handleTargetNameCollisions({
+			nodes: state.nodes,
+			srcName: action.input.targetName || node.name,
+			targetParentFolder: action.input.targetParentFolder || null
+		});
+		const newNode = {
+			...node,
+			id: action.input.targetId,
+			slug: action.input.targetId,
+			name,
+			parentFolder: action.input.targetParentFolder || null
+		};
+		state.nodes.push(newNode);
+		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		if (isFileNode(newNode)) dispatch?.({
+			type: "COPY_CHILD_DOCUMENT",
+			input: {
+				id: action.input.srcId,
+				newId: action.input.targetId
+			}
+		});
+	},
+	moveNodeOperation(state, action) {
+		if (action.input.srcFolder === action.input.targetParentFolder) throw new Error("Circular Reference Error: Attempting to move a node to its current parent folder");
+		const node = state.nodes.find((node) => node.id === action.input.srcFolder);
+		if (!node) throw new Error(`Node with id ${action.input.srcFolder} not found`);
+		const name = handleTargetNameCollisions({
+			nodes: state.nodes,
+			srcName: node.name,
+			targetParentFolder: action.input.targetParentFolder || null
+		});
+		if (isFolderNode(node)) {
+			if (getDescendants(node, state.nodes).find((descendant) => descendant.id === action.input.targetParentFolder)) throw new Error("Circular Reference Error: Cannot move a folder to one of its descendants");
+		}
+		state.nodes = state.nodes.map((node) => {
+			if (node.id === action.input.srcFolder) return {
+				...node,
+				name,
+				parentFolder: action.input.targetParentFolder || null
+			};
+			return node;
+		});
+		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+	}
+};
+//#endregion
+//#region document-drive/gen/reducer.ts
+const driveStateReducer = (state, action, dispatch) => {
+	if (isDocumentAction(action)) return state;
+	const typedAction = action;
+	switch (typedAction.type) {
+		case "ADD_FILE":
+			AddFileInputSchema().parse(typedAction.input);
+			nodeReducer.addFileOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "ADD_FOLDER":
+			AddFolderInputSchema().parse(typedAction.input);
+			nodeReducer.addFolderOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "DELETE_NODE":
+			DeleteNodeInputSchema().parse(typedAction.input);
+			nodeReducer.deleteNodeOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "UPDATE_FILE":
+			UpdateFileInputSchema().parse(typedAction.input);
+			nodeReducer.updateFileOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "UPDATE_NODE":
+			UpdateNodeInputSchema().parse(typedAction.input);
+			nodeReducer.updateNodeOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "COPY_NODE":
+			CopyNodeInputSchema().parse(typedAction.input);
+			nodeReducer.copyNodeOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "MOVE_NODE":
+			MoveNodeInputSchema().parse(typedAction.input);
+			nodeReducer.moveNodeOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "SET_DRIVE_NAME":
+			SetDriveNameInputSchema().parse(typedAction.input);
+			driveReducer.setDriveNameOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "SET_DRIVE_ICON":
+			SetDriveIconInputSchema().parse(typedAction.input);
+			driveReducer.setDriveIconOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "SET_SHARING_TYPE":
+			SetSharingTypeInputSchema().parse(typedAction.input);
+			driveReducer.setSharingTypeOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "SET_AVAILABLE_OFFLINE":
+			SetAvailableOfflineInputSchema().parse(typedAction.input);
+			driveReducer.setAvailableOfflineOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "ADD_LISTENER":
+			AddListenerInputSchema().parse(typedAction.input);
+			driveReducer.addListenerOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "REMOVE_LISTENER":
+			RemoveListenerInputSchema().parse(typedAction.input);
+			driveReducer.removeListenerOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "ADD_TRIGGER":
+			AddTriggerInputSchema().parse(typedAction.input);
+			driveReducer.addTriggerOperation(state[typedAction.scope], action, dispatch);
+			break;
+		case "REMOVE_TRIGGER":
+			RemoveTriggerInputSchema().parse(typedAction.input);
+			driveReducer.removeTriggerOperation(state[typedAction.scope], action, dispatch);
+			break;
+		default: return state;
+	}
+};
+const driveDocumentReducer = createReducer(driveStateReducer);
+//#endregion
+//#region document-drive/gen/document-schema.ts
+/** Schema for validating the header object of a Drive document */
+const DriveDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({ documentType: z.literal(driveDocumentType) });
+/** Schema for validating the state object of a Drive document */
+const DrivePHStateSchema = BaseDocumentStateSchema.extend({
+	global: DocumentDriveStateSchema(),
+	local: DocumentDriveLocalStateSchema()
+});
+const DriveDocumentSchema = z.object({
+	header: DriveDocumentHeaderSchema,
+	state: DrivePHStateSchema,
+	initialState: DrivePHStateSchema
+});
+/** Simple helper function to check if a state object is a Drive document state object */
+function isDriveState(state) {
+	return DrivePHStateSchema.safeParse(state).success;
+}
+/** Simple helper function to assert that a document state object is a Drive document state object */
+function assertIsDriveState(state) {
+	DrivePHStateSchema.parse(state);
+}
+/** Simple helper function to check if a document is a Drive document */
+function isDriveDocument(document) {
+	return DriveDocumentSchema.safeParse(document).success;
+}
+/** Simple helper function to assert that a document is a Drive document */
+function assertIsDriveDocument(document) {
+	DriveDocumentSchema.parse(document);
+}
+//#endregion
+//#region document-drive/gen/utils.ts
+const initialGlobalState = {
+	name: "",
+	nodes: [],
+	icon: null
+};
+const initialLocalState = {
+	listeners: [],
+	triggers: [],
+	sharingType: "private",
+	availableOffline: false
+};
+const driveCreateState = (state) => {
+	return {
+		...defaultBaseState(),
+		global: {
+			...initialGlobalState,
+			...state?.global
+		},
+		local: {
+			...initialLocalState,
+			...state?.local
+		}
+	};
+};
+const driveCreateDocument = (state) => {
+	const document = baseCreateDocument(driveCreateState, state);
+	document.header.documentType = driveDocumentType;
+	document.header.id = generateId();
+	return document;
+};
+const driveSaveToFileHandle = (document, input) => {
+	return baseSaveToFileHandle(document, input);
+};
+const driveLoadFromInput = (input) => {
+	return baseLoadFromInput(input, driveDocumentReducer);
+};
+const isStateOfType = (state) => {
+	return isDriveState(state);
+};
+const assertIsStateOfType = (state) => {
+	assertIsDriveState(state);
+};
+const isDocumentOfType = (document) => {
+	return isDriveDocument(document);
+};
+const assertIsDocumentOfType = (document) => {
+	assertIsDriveDocument(document);
+};
+//#endregion
+//#region document-drive/module.ts
+const driveDocumentModelModule = {
+	actions: creators_exports,
+	reducer: driveDocumentReducer,
+	documentModel: createState$1(defaultBaseState(), driveDocumentModel),
+	utils: {
+		fileExtension: driveDocumentFileExtension,
+		createState: driveCreateState,
+		createDocument: driveCreateDocument,
+		loadFromInput: driveLoadFromInput,
+		saveToFileHandle: driveSaveToFileHandle,
+		isStateOfType,
+		assertIsStateOfType,
+		isDocumentOfType,
+		assertIsDocumentOfType
+	}
+};
+//#endregion
+export { AddFileInputSchema, AddFolderInputSchema, AddListenerInputSchema, AddTriggerInputSchema, CopyNodeInputSchema, DeleteNodeInputSchema, DocumentDriveLocalStateSchema, DocumentDriveStateSchema, FileNodeSchema, FolderNodeSchema, ListenerCallInfoInputSchema, ListenerCallInfoSchema, ListenerFilterInputSchema, ListenerFilterSchema, ListenerInputSchema, ListenerSchema, MoveNodeInputSchema, NodeSchema, PullResponderTriggerDataInputSchema, PullResponderTriggerDataSchema, RemoveListenerInputSchema, RemoveTriggerInputSchema, SetAvailableOfflineInputSchema, SetDriveIconInputSchema, SetDriveNameInputSchema, SetSharingTypeInputSchema, TransmitterTypeSchema, TriggerDataSchema, TriggerInputSchema, TriggerSchema, TriggerTypeSchema, UpdateFileInputSchema, UpdateNodeInputSchema, addFile, addFolder, addListener, addTrigger, assertIsDocumentOfType, assertIsStateOfType, copyNode, createGlobalState, createLocalState, createState, defaultGlobalState, defaultLocalState, defaultPHState, definedNonNullAnySchema, deleteNode, driveCreateDocument, driveCreateState, driveDocumentFileExtension, driveDocumentModel, driveDocumentModelModule, driveDocumentReducer, driveDocumentType, driveLoadFromInput, driveReducer, driveSaveToFileHandle, escapeRegExp, generateNodesCopy, getAncestors, getDescendants, getNextCopyNumber, handleTargetNameCollisions, initialGlobalState, initialLocalState, isDefinedNonNullAny, isDocumentOfType, isFileNode, isFolderNode, isStateOfType, isValidName, moveNode, nodeReducer, removeListener, removeTrigger, setAvailableOffline, setDriveIcon, setDriveName, setSharingType, updateFile, updateNode };
+
+//# sourceMappingURL=index.js.map