@powerhousedao/powerhouse-vetra-packages 6.2.3-dev.10 → 6.2.3-dev.12

package/dist/node/index.mjs

@@ -1,8 +1,13 @@
-import { c as any, h as object, l as array, p as literal, v as string } from "./dist-DT7jI9ol.mjs";
-import { C as baseCreateDocument, E as baseSaveToFileHandle, M as createState, O as createAction, P as defaultBaseState, S as baseActions, T as baseLoadFromInputVersioned, V as isDocumentAction, ft as generateId, g as BaseDocumentStateSchema, h as BaseDocumentHeaderSchema, j as createReducer, k as createBaseState, p as documentModelDocumentModelModule, r as driveDocumentModelModule, w as baseLoadFromInput } from "./document-drive-DuGBBYw5.mjs";
-import { t as require_main } from "./main-7sul-YJl.mjs";
+import { a as __toCommonJS, t as __commonJSMin } from "./chunk-17FXJ3dL.mjs";
+import { n as tslib_es6_exports, t as init_tslib_es6 } from "./tslib.es6-DdiHgz9e.mjs";
+import { t as require_graphql } from "./graphql-BvV3tC1U.mjs";
 import { DocumentModelEditor } from "./editors/document-model-editor/module.mjs";
 import { GenericDriveExplorer } from "./editors/generic-drive-explorer/module.mjs";
+import { baseCreateDocument, baseLoadFromInput, baseSaveToFileHandle, createReducer, createState, defaultBaseState, generateId, isDocumentAction } from "@powerhousedao/shared/document-model";
+import { BaseDocumentHeaderSchema, BaseDocumentStateSchema, baseActions, baseCreateDocument as baseCreateDocument$1, baseLoadFromInputVersioned, baseSaveToFileHandle as baseSaveToFileHandle$1, createAction, createBaseState, createReducer as createReducer$1, createState as createState$1, defaultBaseState as defaultBaseState$1, documentModelDocumentModelModule, isDocumentAction as isDocumentAction$1 } from "document-model";
+import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
+import * as z$1 from "zod";
+import { z } from "zod";
 //#region powerhouse.manifest.json
 var powerhouse_manifest_default = {
 	name: "Common",
@@ -70,8 +75,124 @@ var powerhouse_manifest_default = {
 	importScripts: []
 };
 //#endregion
+//#region ../../node_modules/.pnpm/graphql-tag@2.12.6_graphql@16.12.0/node_modules/graphql-tag/lib/graphql-tag.umd.js
+var require_graphql_tag_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? factory(exports, (init_tslib_es6(), __toCommonJS(tslib_es6_exports)), require_graphql()) : typeof define === "function" && define.amd ? define([
+			"exports",
+			"tslib",
+			"graphql"
+		], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["graphql-tag"] = {}, global.tslib, global.graphql));
+	})(exports, (function(exports$1, tslib, graphql) {
+		"use strict";
+		var docCache = /* @__PURE__ */ new Map();
+		var fragmentSourceMap = /* @__PURE__ */ new Map();
+		var printFragmentWarnings = true;
+		var experimentalFragmentVariables = false;
+		function normalize(string) {
+			return string.replace(/[\s,]+/g, " ").trim();
+		}
+		function cacheKeyFromLoc(loc) {
+			return normalize(loc.source.body.substring(loc.start, loc.end));
+		}
+		function processFragments(ast) {
+			var seenKeys = /* @__PURE__ */ new Set();
+			var definitions = [];
+			ast.definitions.forEach(function(fragmentDefinition) {
+				if (fragmentDefinition.kind === "FragmentDefinition") {
+					var fragmentName = fragmentDefinition.name.value;
+					var sourceKey = cacheKeyFromLoc(fragmentDefinition.loc);
+					var sourceKeySet = fragmentSourceMap.get(fragmentName);
+					if (sourceKeySet && !sourceKeySet.has(sourceKey)) {
+						if (printFragmentWarnings) console.warn("Warning: fragment with name " + fragmentName + " already exists.\ngraphql-tag enforces all fragment names across your application to be unique; read more about\nthis in the docs: http://dev.apollodata.com/core/fragments.html#unique-names");
+					} else if (!sourceKeySet) fragmentSourceMap.set(fragmentName, sourceKeySet = /* @__PURE__ */ new Set());
+					sourceKeySet.add(sourceKey);
+					if (!seenKeys.has(sourceKey)) {
+						seenKeys.add(sourceKey);
+						definitions.push(fragmentDefinition);
+					}
+				} else definitions.push(fragmentDefinition);
+			});
+			return tslib.__assign(tslib.__assign({}, ast), { definitions });
+		}
+		function stripLoc(doc) {
+			var workSet = new Set(doc.definitions);
+			workSet.forEach(function(node) {
+				if (node.loc) delete node.loc;
+				Object.keys(node).forEach(function(key) {
+					var value = node[key];
+					if (value && typeof value === "object") workSet.add(value);
+				});
+			});
+			var loc = doc.loc;
+			if (loc) {
+				delete loc.startToken;
+				delete loc.endToken;
+			}
+			return doc;
+		}
+		function parseDocument(source) {
+			var cacheKey = normalize(source);
+			if (!docCache.has(cacheKey)) {
+				var parsed = graphql.parse(source, {
+					experimentalFragmentVariables,
+					allowLegacyFragmentVariables: experimentalFragmentVariables
+				});
+				if (!parsed || parsed.kind !== "Document") throw new Error("Not a valid GraphQL document.");
+				docCache.set(cacheKey, stripLoc(processFragments(parsed)));
+			}
+			return docCache.get(cacheKey);
+		}
+		function gql(literals) {
+			var args = [];
+			for (var _i = 1; _i < arguments.length; _i++) args[_i - 1] = arguments[_i];
+			if (typeof literals === "string") literals = [literals];
+			var result = literals[0];
+			args.forEach(function(arg, i) {
+				if (arg && arg.kind === "Document") result += arg.loc.source.body;
+				else result += arg;
+				result += literals[i + 1];
+			});
+			return parseDocument(result);
+		}
+		function resetCaches() {
+			docCache.clear();
+			fragmentSourceMap.clear();
+		}
+		function disableFragmentWarnings() {
+			printFragmentWarnings = false;
+		}
+		function enableExperimentalFragmentVariables() {
+			experimentalFragmentVariables = true;
+		}
+		function disableExperimentalFragmentVariables() {
+			experimentalFragmentVariables = false;
+		}
+		var extras = {
+			gql,
+			resetCaches,
+			disableFragmentWarnings,
+			enableExperimentalFragmentVariables,
+			disableExperimentalFragmentVariables
+		};
+		(function(gql_1) {
+			gql_1.gql = extras.gql, gql_1.resetCaches = extras.resetCaches, gql_1.disableFragmentWarnings = extras.disableFragmentWarnings, gql_1.enableExperimentalFragmentVariables = extras.enableExperimentalFragmentVariables, gql_1.disableExperimentalFragmentVariables = extras.disableExperimentalFragmentVariables;
+		})(gql || (gql = {}));
+		gql["default"] = gql;
+		exports$1.default = gql;
+		exports$1.disableExperimentalFragmentVariables = disableExperimentalFragmentVariables;
+		exports$1.disableFragmentWarnings = disableFragmentWarnings;
+		exports$1.enableExperimentalFragmentVariables = enableExperimentalFragmentVariables;
+		exports$1.gql = gql;
+		exports$1.resetCaches = resetCaches;
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+	}));
+}));
+//#endregion
 //#region ../reactor-drive/dist/index.js
-var import_main = require_main();
+var import_main = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_graphql_tag_umd().gql;
+})))();
 const REACTOR_DRIVE_DOCUMENT_TYPE = "powerhouse/reactor-drive";
 const REACTOR_DRIVE_FILE_EXTENSION = "phrd";
 function setDriveNameAction(input) {
@@ -417,26 +538,26 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region ../reactor-group/dist/module-DuRVS7HX.js
 const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
-any().refine((v) => isDefinedNonNullAny(v));
+z$1.any().refine((v) => isDefinedNonNullAny(v));
 function AddMemberInputSchema() {
-	return object({ address: string() });
+	return z$1.object({ address: z$1.string() });
 }
 function ReactorGroupStateSchema() {
-	return object({
-		__typename: literal("ReactorGroupState").optional(),
-		description: string(),
-		members: array(string()),
-		name: string()
+	return z$1.object({
+		__typename: z$1.literal("ReactorGroupState").optional(),
+		description: z$1.string(),
+		members: z$1.array(z$1.string()),
+		name: z$1.string()
 	});
 }
 function RemoveMemberInputSchema() {
-	return object({ address: string() });
+	return z$1.object({ address: z$1.string() });
 }
 function SetGroupDescriptionInputSchema() {
-	return object({ description: string() });
+	return z$1.object({ description: z$1.string() });
 }
 function SetGroupNameInputSchema() {
-	return object({ name: string() });
+	return z$1.object({ name: z$1.string() });
 }
 /**
 * WARNING: DO NOT EDIT
@@ -647,7 +768,7 @@ const reactorGroupGroupOperations = {
 	}
 };
 const stateReducer = (state, action, dispatch) => {
-	if (isDocumentAction(action)) return state;
+	if (isDocumentAction$1(action)) return state;
 	switch (action.type) {
 		case "SET_GROUP_NAME":
 			SetGroupNameInputSchema().parse(action.input);
@@ -668,7 +789,7 @@ const stateReducer = (state, action, dispatch) => {
 		default: return state;
 	}
 };
-const reducer = createReducer(stateReducer);
+const reducer = createReducer$1(stateReducer);
 const supportedVersions = [1];
 const reactorGroupUpgradeManifest = {
 	documentType: "powerhouse/reactor-group",
@@ -686,10 +807,10 @@ const reactorGroupDocumentType = "powerhouse/reactor-group";
 * This file is auto-generated and updated by codegen
 */
 /** Schema for validating the header object of a ReactorGroup document */
-const ReactorGroupDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({ documentType: literal(reactorGroupDocumentType) });
+const ReactorGroupDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({ documentType: z.literal(reactorGroupDocumentType) });
 /** Schema for validating the state object of a ReactorGroup document */
 const ReactorGroupPHStateSchema = BaseDocumentStateSchema.extend({ global: ReactorGroupStateSchema() });
-const ReactorGroupDocumentSchema = object({
+const ReactorGroupDocumentSchema = z.object({
 	header: ReactorGroupDocumentHeaderSchema,
 	state: ReactorGroupPHStateSchema,
 	initialState: ReactorGroupPHStateSchema
@@ -735,10 +856,10 @@ const utils$1 = {
 		};
 	},
 	createDocument(state) {
-		return baseCreateDocument(utils$1.createState, state, reactorGroupDocumentType);
+		return baseCreateDocument$1(utils$1.createState, state, reactorGroupDocumentType);
 	},
 	saveToFileHandle(document, input) {
-		return baseSaveToFileHandle(document, input);
+		return baseSaveToFileHandle$1(document, input);
 	},
 	loadFromInput(input) {
 		return baseLoadFromInputVersioned(input, {
@@ -774,7 +895,7 @@ const documentModels = [
 			...utils$1,
 			...utils_exports
 		},
-		documentModel: createState(defaultBaseState(), documentModel)
+		documentModel: createState$1(defaultBaseState$1(), documentModel)
 	}
 ];
 //#endregion