@metabase/client 0.0.0-stage → 0.1.1

package/dist/version/features.js

@@ -0,0 +1,171 @@
+import { KNOWN_RANGE } from "./known-range.js";
+import { z } from "zod";
+//#region src/version/features.ts
+const FEATURE_RULES = {
+	dataActionCollections: { since: 65 },
+	dataActionsWithoutModel: { since: 65 },
+	dataApps: {
+		since: 65,
+		tokenFeature: "data-apps"
+	},
+	transforms: { since: 59 },
+	transformJobActivation: { since: 61 },
+	measures: { since: 59 },
+	collectionItemMeasures: { since: 61 },
+	explorations: { since: 65 },
+	tableFromDefinition: { since: 64 },
+	library: {
+		since: 59,
+		tokenFeature: "library"
+	},
+	libraryDashboards: { since: 65 },
+	tablePublishTargetCollection: { since: 62 },
+	remoteSync: {
+		since: 58,
+		tokenFeature: "remote_sync"
+	},
+	remoteSyncRemoteChanges: {
+		since: 59,
+		tokenFeature: "remote_sync"
+	},
+	remoteSyncCollectionsOnlyUpdate: { since: 60 },
+	remoteSyncExportPreflight: {
+		since: 63,
+		tokenFeature: "remote_sync"
+	},
+	remoteSyncBranchGuard: { since: 63 },
+	remoteSyncMerge: {
+		since: 63,
+		tokenFeature: "remote_sync"
+	},
+	contentTranslation: {
+		since: 58,
+		tokenFeature: "content_translation"
+	},
+	contentVerification: {
+		since: 58,
+		tokenFeature: "content_verification"
+	},
+	transformTargetTableId: { since: 61 },
+	transformSourceTablesAsList: { since: 60 },
+	transformTargetTableLinkedOnCreate: {
+		since: 61,
+		until: 61
+	},
+	transformJobRunIdIsNumeric: { since: 64 },
+	transformCheckpointReset: { since: 60 },
+	fieldDataSensitivity: { since: 64 },
+	fieldRemappingAppendsDisplayColumns: {
+		since: 58,
+		until: 59
+	},
+	transformDagRuns: { since: 64 },
+	unifiedTransformRuns: { since: 64 },
+	transformTests: {
+		since: 65,
+		tokenFeature: "transforms-testing"
+	},
+	libraryChildrenCarryType: { since: 62 },
+	collectionItemsTotalOnEmptyPage: { since: 64 },
+	invalidMbqlIsBadRequest: { since: 59 },
+	boxplotDisplay: { since: 59 },
+	nativeTableTemplateTag: { since: 59 },
+	smartLinkMeasureModel: { since: 60 },
+	dashboardSubscriptionFilters: {
+		since: 58,
+		tokenFeature: "dashboard_subscription_filters"
+	},
+	dependencyGraph: {
+		since: 58,
+		tokenFeature: "dependencies"
+	},
+	dependencyItemListings: {
+		since: 59,
+		tokenFeature: "dependencies"
+	},
+	dependencyAsyncBackfill: {
+		since: 60,
+		tokenFeature: "dependencies"
+	},
+	measureDependencyGraph: { since: 59 },
+	actionDependencyGraph: { since: 65 },
+	tableListAccessFilters: { since: 59 },
+	tableListTransformTargets: { since: 60 },
+	tableListPublishedFilter: { since: 63 },
+	tableUnusedFilter: {
+		since: 58,
+		tokenFeature: "dependencies"
+	},
+	tableDataLayerTiers: { since: 59 },
+	bulkTableEdit: { since: 59 },
+	tableUserValueWithdrawal: { since: 64 },
+	bulkTableSync: { since: 59 },
+	erd: {
+		since: 62,
+		tokenFeature: "schema-viewer"
+	},
+	documentCopy: { since: 59 },
+	transformInspector: {
+		since: 60,
+		tokenFeature: "transforms-python"
+	},
+	pythonLibrary: {
+		since: 58,
+		tokenFeature: "transforms-python"
+	},
+	pythonTestRun: {
+		since: 58,
+		tokenFeature: "transforms-python"
+	},
+	sourceReplacement: {
+		since: 60,
+		tokenFeature: "dependencies"
+	},
+	metricDefinitionQuery: { since: 60 },
+	metricDimensionListing: { since: 64 },
+	oauthFullAccessScopeUnadvertised: { since: 64 },
+	exportCsvByteOrderMark: { since: 63 }
+};
+function isFeatureName(name) {
+	return Object.hasOwn(FEATURE_RULES, name);
+}
+const FEATURE_NAMES = Object.keys(FEATURE_RULES).filter(isFeatureName);
+const Features = z.record(z.enum(FEATURE_NAMES), z.boolean());
+/**
+* Which servers hold `feature`, as a reader says it: the majors its rule spans and the token
+* feature it needs, each left out where every supported server meets it.
+*/
+function featureAvailability(feature) {
+	const rule = FEATURE_RULES[feature];
+	const token = rule.tokenFeature === void 0 ? null : `token ${rule.tokenFeature}`;
+	const parts = [majorSpan(rule), token].filter((part) => part !== null);
+	if (parts.length === 0) throw new Error(`${feature} holds on every supported server, so it gates nothing`);
+	return parts.join(", ");
+}
+function majorSpan(rule) {
+	const floor = rule.since > KNOWN_RANGE.min ? `v${rule.since}` : null;
+	if (rule.until === void 0) return floor === null ? null : `${floor}+`;
+	if (floor === null) return `up to v${rule.until}`;
+	return rule.since === rule.until ? `${floor} only` : `${floor}-v${rule.until}`;
+}
+function evaluateFeatures(major, tokenFeatures) {
+	const entries = FEATURE_NAMES.map((name) => [name, ruleHolds(FEATURE_RULES[name], major, tokenFeatures)]);
+	return Features.parse(Object.fromEntries(entries));
+}
+function ruleHolds(rule, major, tokenFeatures) {
+	return ruleGap(rule, major, tokenFeatures) === null;
+}
+function ruleGap(rule, major, tokenFeatures) {
+	if (!versionHolds(rule, major)) return { kind: "version" };
+	if (rule.tokenFeature === void 0) return null;
+	return tokenFeatures !== null && tokenFeatures[rule.tokenFeature] === true ? null : {
+		kind: "token",
+		tokenFeature: rule.tokenFeature
+	};
+}
+function versionHolds(rule, major) {
+	if (major === "development") return rule.until === void 0;
+	return major >= rule.since && (rule.until === void 0 || major <= rule.until);
+}
+//#endregion
+export { FEATURE_NAMES, FEATURE_RULES, Features, evaluateFeatures, featureAvailability, isFeatureName, ruleGap };

package/dist/version/input-gates.d.ts

@@ -0,0 +1,2 @@
+import { a as PresentTrigger, c as inputGatesOf, i as NonEmptyTrigger, n as GateTrigger, o as ValuesTrigger, r as InputGate, s as gateTriggered, t as GateEffect } from "../input-gates-DwKoTJVQ.js";
+export { GateEffect, GateTrigger, InputGate, NonEmptyTrigger, PresentTrigger, ValuesTrigger, gateTriggered, inputGatesOf };

package/dist/version/input-gates.js

@@ -0,0 +1,13 @@
+import { n as inputGatesOf } from "../input-gate-registry-Dai7SfXb.js";
+//#region src/version/input-gates.ts
+/** Whether `value`, as a caller passes it for the gated field, is one the gate applies to. */
+function gateTriggered(gate, value) {
+	const { when } = gate;
+	switch (when.kind) {
+		case "present": return value !== void 0;
+		case "values": return when.values.some((gated) => gated === value);
+		case "nonEmpty": return Array.isArray(value) && value.length > 0;
+	}
+}
+//#endregion
+export { gateTriggered, inputGatesOf };

package/dist/version/known-range.d.ts

@@ -0,0 +1,2 @@
+import { t as KNOWN_RANGE } from "../known-range-DTOBgTEC.js";
+export { KNOWN_RANGE };

package/dist/version/known-range.js

@@ -0,0 +1,7 @@
+//#region src/version/known-range.ts
+const KNOWN_RANGE = {
+	min: 58,
+	max: 64
+};
+//#endregion
+export { KNOWN_RANGE };

package/dist/version/probe.d.ts

@@ -0,0 +1,2 @@
+import { At as profileFromProperties, Ct as PROBE_PATH, Dt as ServerInfo, Et as ProbeOptions, Ot as probeBudget, Tt as ProbeBudget, jt as serverInfoFromProperties, kt as probeServer, wt as PROBE_TIMEOUT_MS } from "../transport-BsXqRujn.js";
+export { PROBE_PATH, PROBE_TIMEOUT_MS, ProbeBudget, ProbeOptions, ServerInfo, probeBudget, probeServer, profileFromProperties, serverInfoFromProperties };

package/dist/version/probe.js

@@ -0,0 +1,30 @@
+import { SessionProperties } from "../domain/session-properties.js";
+import { editionFromTag, parseTag } from "./tag.js";
+import { createServerProfile } from "./profile.js";
+//#region src/version/probe.ts
+const PROBE_PATH = "/api/session/properties";
+const PROBE_TIMEOUT_MS = 1e4;
+async function probeServer(client, opts = {}) {
+	return serverInfoFromProperties(await client.requestParsed(SessionProperties, PROBE_PATH, probeBudget(opts)));
+}
+function probeBudget(opts) {
+	return {
+		timeoutMs: opts.timeoutMs ?? 1e4,
+		retries: opts.retries ?? 0
+	};
+}
+function serverInfoFromProperties(properties) {
+	const { tag } = properties.version;
+	return {
+		version: parseTag(tag),
+		edition: editionFromTag(tag),
+		date: properties.version.date ?? null,
+		hash: properties.version.hash ?? null,
+		tokenFeatures: properties["token-features"] ?? null
+	};
+}
+function profileFromProperties(properties) {
+	return createServerProfile(serverInfoFromProperties(properties));
+}
+//#endregion
+export { PROBE_PATH, PROBE_TIMEOUT_MS, probeBudget, probeServer, profileFromProperties, serverInfoFromProperties };

package/dist/version/profile.d.ts

@@ -0,0 +1,2 @@
+import { St as featureGap, bt as Skew, xt as createServerProfile, yt as ServerProfile } from "../transport-BsXqRujn.js";
+export { ServerProfile, Skew, createServerProfile, featureGap };

package/dist/version/profile.js

@@ -0,0 +1,64 @@
+import { TokenFeatures } from "../domain/session-properties.js";
+import { KNOWN_RANGE } from "./known-range.js";
+import { FEATURE_RULES, Features, evaluateFeatures, ruleGap } from "./features.js";
+import { Edition, ServerVersion } from "./tag.js";
+import { z } from "zod";
+//#region src/version/profile.ts
+const Skew = z.enum([
+	"supported",
+	"older-than-known",
+	"newer-than-known",
+	"development"
+]);
+const ServerProfile = z.object({
+	version: ServerVersion,
+	buildDate: z.string().nullable(),
+	hash: z.string().nullable(),
+	edition: Edition,
+	tokenFeatures: TokenFeatures.nullable(),
+	features: Features,
+	skew: Skew
+});
+function createServerProfile(info) {
+	const placement = place(info.version);
+	return {
+		version: info.version,
+		buildDate: info.date,
+		hash: info.hash,
+		edition: detectEdition(info),
+		tokenFeatures: info.tokenFeatures,
+		features: evaluateFeatures(placement.major, info.tokenFeatures),
+		skew: placement.skew
+	};
+}
+function featureGap(profile, feature) {
+	const placement = place(profile.version);
+	return ruleGap(FEATURE_RULES[feature], placement.major, profile.tokenFeatures);
+}
+function place(version) {
+	if (version.kind === "development") return {
+		major: "development",
+		skew: "development"
+	};
+	if (version.major > KNOWN_RANGE.max) return {
+		major: KNOWN_RANGE.max + 1,
+		skew: "newer-than-known"
+	};
+	if (version.major < KNOWN_RANGE.min) return {
+		major: version.major,
+		skew: "older-than-known"
+	};
+	return {
+		major: version.major,
+		skew: "supported"
+	};
+}
+function detectEdition(info) {
+	if (info.edition !== null) return info.edition;
+	return grantsAnyFeature(info.tokenFeatures) ? "ee" : "oss";
+}
+function grantsAnyFeature(tokenFeatures) {
+	return tokenFeatures !== null && Object.values(tokenFeatures).some((enabled) => enabled);
+}
+//#endregion
+export { ServerProfile, Skew, createServerProfile, featureGap };

package/dist/version/requirement-check.d.ts

@@ -0,0 +1,2 @@
+import { n as featureFailures, r as supersedingFeature, t as checkFeatures } from "../requirement-check-glU7wqhQ.js";
+export { checkFeatures, featureFailures, supersedingFeature };

package/dist/version/requirement-check.js

@@ -0,0 +1,62 @@
+import { FEATURE_RULES } from "./features.js";
+import { missingTokenFeatureMessage, versionTooOldMessage } from "./capability-error.js";
+import { describeVersion } from "./tag.js";
+import { featureGap } from "./profile.js";
+//#region src/version/requirement-check.ts
+/** The first of `features` the profile lacks, or `null` when it has every one. */
+function checkFeatures(features, profile) {
+	for (const feature of features) {
+		const gap = featureGap(profile, feature);
+		if (gap !== null) return describeGap(gap, feature, profile);
+	}
+	return null;
+}
+/**
+* The verdict that the profile has `feature`, which takes the value `detail` describes out of the
+* server's vocabulary, or `null` when the profile lacks it.
+*/
+function supersedingFeature(feature, profile, detail) {
+	if (featureGap(profile, feature) !== null) return null;
+	const rule = FEATURE_RULES[feature];
+	return {
+		reason: "superseded-by-feature",
+		detail,
+		feature,
+		since: rule.since,
+		tokenFeature: rule.tokenFeature ?? null,
+		serverVersion: profile.version.tag
+	};
+}
+/**
+* Every one of `features` the profile lacks, each once and in the order given, so a caller that
+* goes on past the first still hears of the rest.
+*/
+function featureFailures(features, profile) {
+	return [...new Set(features)].flatMap((feature) => {
+		const failure = checkFeatures([feature], profile);
+		return failure === null ? [] : [failure];
+	});
+}
+function describeGap(gap, feature, profile) {
+	const rule = FEATURE_RULES[feature];
+	const serverVersion = profile.version.tag;
+	const tokenFeature = rule.tokenFeature ?? null;
+	if (gap.kind === "token") return {
+		reason: "missing-token-feature",
+		detail: missingTokenFeatureMessage(gap.tokenFeature),
+		feature,
+		since: rule.since,
+		tokenFeature,
+		serverVersion
+	};
+	return {
+		reason: "version-too-old",
+		detail: versionTooOldMessage(rule.since, describeVersion(profile.version)),
+		feature,
+		since: rule.since,
+		tokenFeature,
+		serverVersion
+	};
+}
+//#endregion
+export { checkFeatures, featureFailures, supersedingFeature };

package/dist/version/requirements.d.ts

@@ -0,0 +1,2 @@
+import { a as methodRequirements, i as isMethodKey, n as METHOD_REQUIREMENTS, r as MethodKey, t as METHOD_KEYS } from "../requirements-Dx_ZVzl7.js";
+export { METHOD_KEYS, METHOD_REQUIREMENTS, MethodKey, isMethodKey, methodRequirements };

package/dist/version/requirements.js

@@ -0,0 +1,229 @@
+//#region src/version/requirements.ts
+const METHOD_REQUIREMENTS = {
+	"apiKey.list": [],
+	"apiKey.create": [],
+	"apiKey.delete": [],
+	"card.list": [],
+	"card.get": [],
+	"card.create": [],
+	"card.update": [],
+	"card.archive": [],
+	"card.query": [],
+	"card.exportQuery": [],
+	"card.queryMetadata": [],
+	"collection.list": [],
+	"collection.get": [],
+	"collection.create": [],
+	"collection.update": [],
+	"collection.archive": [],
+	"collection.itemPages": [],
+	"collection.tree": [],
+	"contentTranslation.download": ["contentTranslation"],
+	"contentTranslation.upload": ["contentTranslation"],
+	"dashboard.list": [],
+	"dashboard.get": [],
+	"dashboard.create": [],
+	"dashboard.update": [],
+	"dashboard.archive": [],
+	"dashboard.copy": [],
+	"dashboard.updateDashcard": [],
+	"dashboard.checkCardReferences": [],
+	"dashboard.parameterValues": [],
+	"dashboard.searchParameterValues": [],
+	"dataAction.list": [],
+	"dataAction.get": [],
+	"dataAction.create": ["dataActionsWithoutModel"],
+	"dataAction.update": [],
+	"dataAction.archive": [],
+	"dataAction.delete": [],
+	"dataAction.execute": [],
+	"dataApp.list": ["dataApps"],
+	"dataApp.get": ["dataApps"],
+	"dataApp.create": ["dataApps"],
+	"dataApp.update": ["dataApps"],
+	"dataApp.replaceBundle": ["dataApps"],
+	"dataApp.typedSchema": ["dataApps"],
+	"dataApp.delete": ["dataApps"],
+	"database.list": [],
+	"database.get": [],
+	"database.update": [],
+	"database.schemas": [],
+	"database.schemaTables": [],
+	"database.syncSchema": [],
+	"database.rescanValues": [],
+	"dataset.query": [],
+	"dataset.native": [],
+	"dataset.queryMetadata": [],
+	"dataset.exportQuery": [],
+	"dependency.breakingPages": ["dependencyItemListings"],
+	"dependency.broken": ["dependencyItemListings"],
+	"dependency.dependents": ["dependencyItemListings"],
+	"dependency.graph": ["dependencyGraph"],
+	"dependency.unreferencedPages": ["dependencyItemListings"],
+	"document.list": [],
+	"document.get": [],
+	"document.create": [],
+	"document.update": [],
+	"document.archive": [],
+	"document.copy": ["documentCopy"],
+	"eidTranslation.translate": [],
+	"erd.get": ["erd"],
+	"field.get": [],
+	"field.update": [],
+	"field.setDataSensitivity": ["fieldDataSensitivity"],
+	"field.search": [],
+	"field.remapping": [],
+	"field.summary": [],
+	"field.values": [],
+	"gitSync.currentTask": ["remoteSync"],
+	"gitSync.cancelTask": ["remoteSync"],
+	"gitSync.isDirty": ["remoteSync"],
+	"gitSync.dirty": ["remoteSync"],
+	"gitSync.hasRemoteChanges": ["remoteSyncRemoteChanges"],
+	"gitSync.import": ["remoteSync"],
+	"gitSync.export": ["remoteSync"],
+	"gitSync.exportPreflight": ["remoteSyncExportPreflight"],
+	"gitSync.stash": ["remoteSync"],
+	"gitSync.branches": ["remoteSync"],
+	"gitSync.createBranch": ["remoteSync"],
+	"gitSync.setCollectionSynced": ["remoteSync"],
+	"gitSync.syncedCollections": ["remoteSync"],
+	"gitSync.remoteUrl": [],
+	"gitSync.branch": ["remoteSync"],
+	"gitSync.remote": ["remoteSync"],
+	"gitSync.trackedBranch": ["remoteSync"],
+	"gitSync.waitForTask": ["remoteSync"],
+	"glossary.list": [],
+	"glossary.create": [],
+	"glossary.update": [],
+	"glossary.delete": [],
+	"library.get": ["library"],
+	"library.create": ["library"],
+	"library.ensureDataCollectionId": ["library"],
+	"library.publishTables": ["library"],
+	"library.unpublishTables": ["library"],
+	"metric.query": ["metricDefinitionQuery"],
+	"metric.breakoutValues": ["metricDefinitionQuery"],
+	"metric.dimensions": ["metricDimensionListing"],
+	"measure.list": ["measures"],
+	"measure.get": ["measures"],
+	"measure.create": ["measures"],
+	"measure.update": ["measures"],
+	"measure.archive": ["measures"],
+	"moderationReview.create": ["contentVerification"],
+	"notification.list": [],
+	"notification.get": [],
+	"notification.create": [],
+	"notification.update": [],
+	"notification.archive": [],
+	"notification.send": [],
+	"permission.graph": [],
+	"permission.databaseGraph": [],
+	"permission.groupGraph": [],
+	"pulse.list": [],
+	"pulse.get": [],
+	"pulse.create": [],
+	"pulse.update": [],
+	"pulse.archive": [],
+	"replacement.checkReplaceSource": ["sourceReplacement"],
+	"replacement.replaceSource": ["sourceReplacement"],
+	"replacement.replaceModelWithTransform": ["sourceReplacement"],
+	"replacement.listRuns": ["sourceReplacement"],
+	"replacement.getRun": ["sourceReplacement"],
+	"replacement.cancelRun": ["sourceReplacement"],
+	"revision.list": [],
+	"revision.revert": [],
+	"search.query": [],
+	"segment.list": [],
+	"segment.get": [],
+	"segment.create": [],
+	"segment.update": [],
+	"segment.archive": [],
+	"setting.list": [],
+	"setting.get": [],
+	"setting.set": [],
+	"setup.create": [],
+	"snippet.list": [],
+	"snippet.get": [],
+	"snippet.create": [],
+	"snippet.update": [],
+	"snippet.archive": [],
+	"table.list": [],
+	"table.get": [],
+	"table.update": [],
+	"table.queryMetadata": [],
+	"table.fks": [],
+	"table.syncSchema": [],
+	"table.rescanValues": [],
+	"table.discardValues": [],
+	"table.bulkEdit": ["bulkTableEdit"],
+	"table.bulkSyncSchema": ["bulkTableSync"],
+	"table.bulkRescanValues": ["bulkTableSync"],
+	"table.bulkDiscardValues": ["bulkTableSync"],
+	"table.appendCsv": [],
+	"table.replaceCsv": [],
+	"timeline.list": [],
+	"timeline.get": [],
+	"timeline.events": [],
+	"timeline.create": [],
+	"timeline.update": [],
+	"timeline.archive": [],
+	"timeline.delete": [],
+	"timelineEvent.get": [],
+	"timelineEvent.create": [],
+	"timelineEvent.update": [],
+	"timelineEvent.archive": [],
+	"timelineEvent.delete": [],
+	"transform.list": ["transforms"],
+	"transform.get": ["transforms"],
+	"transform.create": ["transforms"],
+	"transform.update": ["transforms"],
+	"transform.delete": ["transforms"],
+	"transform.deleteTable": ["transforms"],
+	"transform.dependencies": ["transforms"],
+	"transform.cancel": ["transforms"],
+	"transform.getRun": ["transforms"],
+	"transform.runPages": ["transforms"],
+	"transform.runSummaryPages": ["unifiedTransformRuns", "transforms"],
+	"transform.resetCheckpoint": ["transformCheckpointReset", "transforms"],
+	"transform.runDag": ["transformDagRuns", "transforms"],
+	"transform.dagTransforms": ["transformDagRuns", "transforms"],
+	"transform.run": ["transforms"],
+	"transformDagRun.transformRuns": ["transformDagRuns", "transforms"],
+	"transformDagRun.cancel": ["transformDagRuns", "transforms"],
+	"transformInspector.discover": ["transformInspector"],
+	"transformInspector.lens": ["transformInspector"],
+	"transformInspector.query": ["transformInspector"],
+	"transformJob.list": ["transforms"],
+	"transformJob.get": ["transforms"],
+	"transformJob.create": ["transforms"],
+	"transformJob.update": ["transforms"],
+	"transformJob.delete": ["transforms"],
+	"transformJob.run": ["transforms"],
+	"transformJob.transforms": ["transforms"],
+	"transformJob.setActive": ["transformJobActivation", "transforms"],
+	"transformPython.getLibrary": ["pythonLibrary"],
+	"transformPython.updateLibrary": ["pythonLibrary"],
+	"transformPython.testRun": ["pythonTestRun"],
+	"transformTag.list": ["transforms"],
+	"transformTag.create": ["transforms"],
+	"transformTag.update": ["transforms"],
+	"transformTag.delete": ["transforms"],
+	"transformTest.list": ["transformTests"],
+	"transformTest.get": ["transformTests"],
+	"transformTest.create": ["transformTests"],
+	"transformTest.update": ["transformTests"],
+	"transformTest.delete": ["transformTests"],
+	"transformTest.run": ["transformTests"],
+	"upload.createFromCsv": [],
+	"user.current": []
+};
+function isMethodKey(key) {
+	return Object.hasOwn(METHOD_REQUIREMENTS, key);
+}
+const METHOD_KEYS = Object.keys(METHOD_REQUIREMENTS).filter(isMethodKey);
+function methodRequirements(key) {
+	return METHOD_REQUIREMENTS[key];
+}
+//#endregion
+export { METHOD_KEYS, METHOD_REQUIREMENTS, isMethodKey, methodRequirements };

package/dist/version/tag.d.ts

@@ -0,0 +1,2 @@
+import { a as StoredServerVersion, c as parseTag, i as ServerVersion, n as Edition, o as describeVersion, r as ReleaseVersion, s as editionFromTag, t as DevelopmentBuild } from "../tag-qzjGGci8.js";
+export { DevelopmentBuild, Edition, ReleaseVersion, ServerVersion, StoredServerVersion, describeVersion, editionFromTag, parseTag };

package/dist/version/tag.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+//#region src/version/tag.ts
+const ReleaseVersion = z.object({
+	kind: z.literal("release"),
+	tag: z.string(),
+	major: z.number().int().nonnegative(),
+	patch: z.number().int().nonnegative()
+});
+const DevelopmentBuild = z.object({
+	kind: z.literal("development"),
+	tag: z.string()
+});
+const ServerVersion = z.discriminatedUnion("kind", [ReleaseVersion, DevelopmentBuild]);
+const Edition = z.enum(["oss", "ee"]);
+const TAG = /^v?([01])\.(\d+)\.(\d+)(?:\.\d+)?(?:-([0-9A-Za-z.-]+))?$/;
+const OSS_EDITION_NUMBER = "0";
+const DEV_BUILD_SUFFIX = "SNAPSHOT";
+function tagParts(tag) {
+	const match = TAG.exec(tag);
+	if (match === null) return null;
+	const [, editionNumber, major, patch, prerelease] = match;
+	if (editionNumber === void 0 || major === void 0 || patch === void 0) return null;
+	return {
+		edition: editionNumber === OSS_EDITION_NUMBER ? "oss" : "ee",
+		major: Number(major),
+		patch: Number(patch),
+		prerelease: prerelease ?? null
+	};
+}
+function parseTag(tag) {
+	const parts = tagParts(tag);
+	if (parts === null || parts.prerelease === DEV_BUILD_SUFFIX) return {
+		kind: "development",
+		tag
+	};
+	return {
+		kind: "release",
+		tag,
+		major: parts.major,
+		patch: parts.patch
+	};
+}
+function editionFromTag(tag) {
+	const parts = tagParts(tag);
+	return parts === null ? null : parts.edition;
+}
+function describeVersion(version) {
+	return version.kind === "release" ? version.tag : `development build ${version.tag}`;
+}
+const StoredServerVersion = z.object({ tag: z.string() }).loose().transform(({ tag }) => parseTag(tag));
+//#endregion
+export { DevelopmentBuild, Edition, ReleaseVersion, ServerVersion, StoredServerVersion, describeVersion, editionFromTag, parseTag };