@powerhousedao/powerhouse-vetra-packages 6.2.0-dev.4 → 6.2.0-dev.40

package/dist/browser/lib-DtwK2kyR.js

@@ -0,0 +1,200 @@
+import { t as parse } from "./parser-CkF6Qt8V.js";
+//#region ../reactor/dist/drive-container-types-BuFNr0j0.js
+/**
+* Error thrown when a document model module is not found in the registry.
+*/
+var ModuleNotFoundError = class extends Error {
+	documentType;
+	requestedVersion;
+	constructor(documentType, version) {
+		const versionSuffix = version !== void 0 ? ` version ${version}` : "";
+		super(`Document model module not found for type: ${documentType}${versionSuffix}`);
+		this.name = "ModuleNotFoundError";
+		this.documentType = documentType;
+		this.requestedVersion = version;
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "ModuleNotFoundError";
+	}
+};
+const DRIVE_COLLECTION_PREFIX = "drive.";
+/**
+* Identifies the collection a remote synchronizes. Collections are drive-level
+* abstractions (document-drive and reactor-drive), so a collection id is the
+* drive document id plus the branch it scopes to rather than an opaque string.
+*
+* The canonical string form (`drive.${branch}.${driveId}`) is produced only by
+* `key` and parsed only by `fromKey`; that string is the wire and storage
+* representation and is byte-for-byte identical to the legacy
+* `driveCollectionId(branch, driveId)` output, so existing `document_collections`
+* rows and persisted remotes remain valid without migration.
+*/
+var DriveCollectionId = class DriveCollectionId {
+	constructor(driveId, branch) {
+		this.driveId = driveId;
+		this.branch = branch;
+	}
+	static forDrive(driveId, branch = "main") {
+		return new DriveCollectionId(driveId, branch);
+	}
+	/**
+	* The single deserializer for the wire/storage form. `branch` may contain
+	* dots, while `driveId` is a dot-free document id, so the drive id is the
+	* final dot-delimited segment.
+	*/
+	static fromKey(key) {
+		if (!key.startsWith(DRIVE_COLLECTION_PREFIX)) throw new Error(`Unsupported collection id: ${key}`);
+		const rest = key.slice(6);
+		const lastDot = rest.lastIndexOf(".");
+		if (lastDot === -1 || lastDot === rest.length - 1) throw new Error(`Malformed drive collection id: ${key}`);
+		return new DriveCollectionId(rest.slice(lastDot + 1), rest.slice(0, lastDot));
+	}
+	get key() {
+		return `${DRIVE_COLLECTION_PREFIX}${this.branch}.${this.driveId}`;
+	}
+	toString() {
+		return this.key;
+	}
+	equals(other) {
+		return this.driveId === other.driveId && this.branch === other.branch;
+	}
+};
+//#endregion
+//#region ../reactor/dist/index.js
+let SyncStatus = /* @__PURE__ */ function(SyncStatus) {
+	SyncStatus["Synced"] = "SYNCED";
+	SyncStatus["Outgoing"] = "OUTGOING";
+	SyncStatus["Incoming"] = "INCOMING";
+	SyncStatus["OutgoingAndIncoming"] = "OUTGOING_AND_INCOMING";
+	SyncStatus["Error"] = "ERROR";
+	return SyncStatus;
+}({});
+//#endregion
+//#region ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+var __assign = function() {
+	__assign = Object.assign || function __assign(t) {
+		for (var s, i = 1, n = arguments.length; i < n; i++) {
+			s = arguments[i];
+			for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+		}
+		return t;
+	};
+	return __assign.apply(this, arguments);
+};
+function __rest(s, e) {
+	var t = {};
+	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+	}
+	return t;
+}
+function __spreadArray(to, from, pack) {
+	if (pack || arguments.length === 2) {
+		for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
+			if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+			ar[i] = from[i];
+		}
+	}
+	return to.concat(ar || Array.prototype.slice.call(from));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/graphql-tag@2.12.6_graphql@16.12.0/node_modules/graphql-tag/lib/index.js
+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 __assign(__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 = 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;
+//#endregion
+export { SyncStatus as a, __spreadArray as i, __assign as n, DriveCollectionId as o, __rest as r, ModuleNotFoundError as s, gql as t };
+
+//# sourceMappingURL=lib-DtwK2kyR.js.map