@hexclave/shared 1.0.0

package/dist/utils/caches.js

@@ -0,0 +1,188 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __env_js = require("./env.js");
+let __maps_js = require("./maps.js");
+let __objects_js = require("./objects.js");
+let __promises_js = require("./promises.js");
+let __stores_js = require("./stores.js");
+
+//#region src/utils/caches.tsx
+/**
+* Can be used to cache the result of a function call, for example for the `use` hook in React.
+*/
+function cacheFunction(f) {
+	const dependenciesMap = new __maps_js.DependenciesMap();
+	return ((...args) => {
+		if (dependenciesMap.has(args)) return dependenciesMap.get(args);
+		const value = f(...args);
+		dependenciesMap.set(args, value);
+		return value;
+	});
+}
+(void 0)?.test("cacheFunction", ({ expect }) => {
+	let callCount = 0;
+	const add = (a, b) => {
+		callCount++;
+		return a + b;
+	};
+	const cachedAdd = cacheFunction(add);
+	expect(cachedAdd(1, 2)).toBe(3);
+	expect(callCount).toBe(1);
+	expect(cachedAdd(1, 2)).toBe(3);
+	expect(callCount).toBe(1);
+	expect(cachedAdd(2, 3)).toBe(5);
+	expect(callCount).toBe(2);
+	let objectCallCount = 0;
+	const createObject = (id) => {
+		objectCallCount++;
+		return { id };
+	};
+	const cachedCreateObject = cacheFunction(createObject);
+	const obj1 = cachedCreateObject(1);
+	expect(obj1).toEqual({ id: 1 });
+	expect(objectCallCount).toBe(1);
+	expect(cachedCreateObject(1)).toBe(obj1);
+	expect(objectCallCount).toBe(1);
+});
+var AsyncCache = class {
+	constructor(_fetcher, _options = {}) {
+		this._fetcher = _fetcher;
+		this._options = _options;
+		this._map = new __maps_js.DependenciesMap();
+		this.isCacheAvailable = this._createKeyed("isCacheAvailable");
+		this.getIfCached = this._createKeyed("getIfCached");
+		this.getOrWait = this._createKeyed("getOrWait");
+		this.forceSetCachedValue = this._createKeyed("forceSetCachedValue");
+		this.forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
+		this.refresh = this._createKeyed("refresh");
+		this.invalidate = this._createKeyed("invalidate");
+		this.onStateChange = this._createKeyed("onStateChange");
+		this.isDirty = this._createKeyed("isDirty");
+	}
+	_createKeyed(functionName) {
+		return (key, ...args) => {
+			const valueCache = this.getValueCache(key);
+			return valueCache[functionName].apply(valueCache, args);
+		};
+	}
+	getValueCache(dependencies) {
+		let cache = this._map.get(dependencies);
+		if (!cache) {
+			cache = new AsyncValueCache(async () => await this._fetcher(dependencies), {
+				...this._options,
+				onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe(dependencies, cb) : void 0
+			});
+			this._map.set(dependencies, cache);
+		}
+		return cache;
+	}
+	async refreshWhere(predicate) {
+		const promises = [];
+		for (const [dependencies, cache] of this._map) if (predicate(dependencies)) promises.push(cache.refresh());
+		await Promise.all(promises);
+	}
+	async invalidateWhere(predicate) {
+		const promises = [];
+		for (const [dependencies, cache] of this._map) if (predicate(dependencies)) promises.push(cache.invalidate().catch(() => void 0));
+		await Promise.all(promises);
+	}
+};
+var AsyncValueCache = class {
+	constructor(fetcher, _options = {}) {
+		this._options = _options;
+		this._subscriptionsCount = 0;
+		this._unsubscribers = [];
+		this._mostRecentRefreshPromiseIndex = 0;
+		this._store = new __stores_js.AsyncStore();
+		this._rateLimitOptions = {
+			concurrency: 1,
+			throttleMs: 300,
+			...(0, __objects_js.filterUndefined)(_options.rateLimiter ?? {})
+		};
+		this._fetcher = (0, __promises_js.rateLimited)(fetcher, {
+			...this._rateLimitOptions,
+			batchCalls: true
+		});
+	}
+	isCacheAvailable() {
+		return this._store.isAvailable();
+	}
+	getIfCached() {
+		return this._store.get();
+	}
+	getOrWait(cacheStrategy) {
+		const cached = this.getIfCached();
+		if (cacheStrategy === "read-write" && cached.status === "ok") return (0, __promises_js.resolved)(cached.data);
+		return this._refetch(cacheStrategy);
+	}
+	_set(value) {
+		this._store.set(value);
+	}
+	_setAsync(value) {
+		if (this._subscriptionsCount === 0 && !(0, __env_js.isBrowserLike)()) this._invalidateCacheSoon();
+		const promise = (0, __promises_js.pending)(value);
+		this._pendingPromise = promise;
+		return (0, __promises_js.pending)(this._store.setAsync(promise).then(() => void 0));
+	}
+	_refetch(cacheStrategy) {
+		if (cacheStrategy === "read-write" && this._pendingPromise) return this._pendingPromise;
+		const promise = (0, __promises_js.pending)(this._fetcher());
+		if (cacheStrategy === "never") return promise;
+		return (0, __promises_js.pending)(this._setAsync(promise).then(() => promise));
+	}
+	forceSetCachedValue(value) {
+		this._set(value);
+	}
+	forceSetCachedValueAsync(value) {
+		return this._setAsync(value);
+	}
+	/**
+	* If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.
+	*/
+	async refresh() {
+		if (this._subscriptionsCount > 0) await this.getOrWait("write-only");
+	}
+	/**
+	* Invalidates the cache, marking it dirty (ie. it will be refreshed on the next read). If anyone is listening to the cache, it will refresh immediately.
+	*/
+	async invalidate() {
+		this._store.setUnavailable();
+		this._pendingPromise = void 0;
+		await this.refresh();
+	}
+	isDirty() {
+		return this._pendingPromise === void 0;
+	}
+	_invalidateCacheSoon() {
+		const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;
+		(0, __promises_js.runAsynchronously)(async () => {
+			await (0, __promises_js.wait)(5e3);
+			if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) await this.invalidate();
+		});
+	}
+	onStateChange(callback) {
+		const storeObj = this._store.onChange(callback);
+		(0, __promises_js.runAsynchronously)(this.getOrWait("read-write"));
+		if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {
+			const unsubscribe = this._options.onSubscribe(() => {
+				(0, __promises_js.runAsynchronously)(this.refresh());
+			});
+			this._unsubscribers.push(unsubscribe);
+		}
+		let hasUnsubscribed = false;
+		return { unsubscribe: () => {
+			if (hasUnsubscribed) return;
+			hasUnsubscribed = true;
+			storeObj.unsubscribe();
+			if (--this._subscriptionsCount === 0) {
+				this._invalidateCacheSoon();
+				for (const unsubscribe of this._unsubscribers) unsubscribe();
+			}
+		} };
+	}
+};
+
+//#endregion
+exports.AsyncCache = AsyncCache;
+exports.cacheFunction = cacheFunction;
+//# sourceMappingURL=caches.js.map

package/dist/utils/caches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caches.js","names":[],"sources":["../../src/utils/caches.tsx"],"sourcesContent":["import { isBrowserLike } from \"./env\";\nimport { DependenciesMap } from \"./maps\";\nimport { filterUndefined } from \"./objects\";\nimport { RateLimitOptions, ReactPromise, pending, rateLimited, resolved, runAsynchronously, wait } from \"./promises\";\nimport { AsyncStore } from \"./stores\";\n\n/**\n * Can be used to cache the result of a function call, for example for the `use` hook in React.\n */\nexport function cacheFunction<F extends Function>(f: F): F {\n  const dependenciesMap = new DependenciesMap<any, any>();\n\n  return ((...args: any) => {\n    if (dependenciesMap.has(args)) {\n      return dependenciesMap.get(args);\n    }\n\n    const value = f(...args);\n    dependenciesMap.set(args, value);\n    return value;\n  }) as any as F;\n}\nimport.meta.vitest?.test(\"cacheFunction\", ({ expect }) => {\n  // Test with a simple function\n  let callCount = 0;\n  const add = (a: number, b: number) => {\n    callCount++;\n    return a + b;\n  };\n\n  const cachedAdd = cacheFunction(add);\n\n  // First call should execute the function\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Second call with same args should use cached result\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Call with different args should execute the function again\n  expect(cachedAdd(2, 3)).toBe(5);\n  expect(callCount).toBe(2);\n\n  // Test with a function that returns objects\n  let objectCallCount = 0;\n  const createObject = (id: number) => {\n    objectCallCount++;\n    return { id };\n  };\n\n  const cachedCreateObject = cacheFunction(createObject);\n\n  // First call should execute the function\n  const obj1 = cachedCreateObject(1);\n  expect(obj1).toEqual({ id: 1 });\n  expect(objectCallCount).toBe(1);\n\n  // Second call with same args should use cached result\n  const obj2 = cachedCreateObject(1);\n  expect(obj2).toBe(obj1); // Same reference\n  expect(objectCallCount).toBe(1);\n});\n\n\ntype CacheStrategy = \"write-only\" | \"read-write\" | \"never\";\n\nexport class AsyncCache<D extends any[], T> {\n  private readonly _map = new DependenciesMap<D, AsyncValueCache<T>>();\n\n  constructor(\n    private readonly _fetcher: (dependencies: D) => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (key: D, refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    // nothing here yet\n  }\n\n  private _createKeyed<FunctionName extends keyof AsyncValueCache<T>>(\n    functionName: FunctionName,\n  ): (key: D, ...args: Parameters<AsyncValueCache<T>[FunctionName]>) => ReturnType<AsyncValueCache<T>[FunctionName]> {\n    return (key: D, ...args) => {\n      const valueCache = this.getValueCache(key);\n      return (valueCache[functionName] as any).apply(valueCache, args);\n    };\n  }\n\n  getValueCache(dependencies: D): AsyncValueCache<T> {\n    let cache = this._map.get(dependencies);\n    if (!cache) {\n      cache = new AsyncValueCache(\n        async () => await this._fetcher(dependencies),\n        {\n          ...this._options,\n          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe!(dependencies, cb) : undefined,\n        },\n      );\n      this._map.set(dependencies, cache);\n    }\n    return cache;\n  }\n\n  async refreshWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.refresh());\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  async invalidateWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.invalidate().catch(() => undefined));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  readonly isCacheAvailable = this._createKeyed(\"isCacheAvailable\");\n  readonly getIfCached = this._createKeyed(\"getIfCached\");\n  readonly getOrWait = this._createKeyed(\"getOrWait\");\n  readonly forceSetCachedValue = this._createKeyed(\"forceSetCachedValue\");\n  readonly forceSetCachedValueAsync = this._createKeyed(\"forceSetCachedValueAsync\");\n  readonly refresh = this._createKeyed(\"refresh\");\n  readonly invalidate = this._createKeyed(\"invalidate\");\n  readonly onStateChange = this._createKeyed(\"onStateChange\");\n  readonly isDirty = this._createKeyed(\"isDirty\");\n}\n\nclass AsyncValueCache<T> {\n  private _store: AsyncStore<T>;\n  private _pendingPromise: ReactPromise<T> | undefined;\n  private _fetcher: () => Promise<T>;\n  private readonly _rateLimitOptions: Omit<RateLimitOptions, \"batchCalls\">;\n  private _subscriptionsCount = 0;\n  private _unsubscribers: (() => void)[] = [];\n  private _mostRecentRefreshPromiseIndex = 0;\n\n  constructor(\n    fetcher: () => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    this._store = new AsyncStore();\n    this._rateLimitOptions = {\n      concurrency: 1,\n      throttleMs: 300,\n      ...filterUndefined(_options.rateLimiter ?? {}),\n    };\n\n\n    this._fetcher = rateLimited(fetcher, {\n      ...this._rateLimitOptions,\n      batchCalls: true,\n    });\n  }\n\n  isCacheAvailable(): boolean {\n    return this._store.isAvailable();\n  }\n\n  getIfCached() {\n    return this._store.get();\n  }\n\n  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    const cached = this.getIfCached();\n    if (cacheStrategy === \"read-write\" && cached.status === \"ok\") {\n      return resolved(cached.data);\n    }\n\n    return this._refetch(cacheStrategy);\n  }\n\n  private _set(value: T): void {\n    this._store.set(value);\n  }\n\n  private _setAsync(value: Promise<T>): ReactPromise<void> {\n    if (this._subscriptionsCount === 0 && !isBrowserLike()) {\n      // if we're in a server-like environment, we'd rather cache less aggressively to avoid memory leaks.\n      // hence, if no one is listening to this cache, let's invalidate it\n      this._invalidateCacheSoon();\n    }\n    const promise = pending(value);\n    this._pendingPromise = promise;\n    return pending(this._store.setAsync(promise).then(() => undefined));\n  }\n\n  private _refetch(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    if (cacheStrategy === \"read-write\" && this._pendingPromise) {\n      return this._pendingPromise;\n    }\n    const promise = pending(this._fetcher());\n    if (cacheStrategy === \"never\") {\n      return promise;\n    }\n    return pending(this._setAsync(promise).then(() => promise));\n  }\n\n  forceSetCachedValue(value: T): void {\n    this._set(value);\n  }\n\n  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void> {\n    return this._setAsync(value);\n  }\n\n  /**\n   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.\n   */\n  async refresh(): Promise<void> {\n    // note that we do the extra check here to save a request if no one is listening to the cache anyway\n    if (this._subscriptionsCount > 0) {\n      await this.getOrWait(\"write-only\");\n    }\n  }\n\n  /**\n   * Invalidates the cache, marking it dirty (ie. it will be refreshed on the next read). If anyone is listening to the cache, it will refresh immediately.\n   */\n  async invalidate(): Promise<void> {\n    this._store.setUnavailable();\n    this._pendingPromise = undefined;\n    await this.refresh();\n  }\n\n  isDirty(): boolean {\n    return this._pendingPromise === undefined;\n  }\n\n  _invalidateCacheSoon(): void {\n    // wait a few seconds; we want to keep the cache up during this time\n    // else we do unnecessary requests if we unsubscribe and then subscribe again immediately\n    const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;\n    runAsynchronously(async () => {\n      await wait(5000);\n      if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {\n        await this.invalidate();\n      }\n    });\n  }\n\n  onStateChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {\n    const storeObj = this._store.onChange(callback);\n\n    runAsynchronously(this.getOrWait(\"read-write\"));\n\n    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {\n      const unsubscribe = this._options.onSubscribe(() => {\n        runAsynchronously(this.refresh());\n      });\n      this._unsubscribers.push(unsubscribe);\n    }\n\n    let hasUnsubscribed = false;\n    return {\n      unsubscribe: () => {\n        if (hasUnsubscribed) return;\n        hasUnsubscribed = true;\n        storeObj.unsubscribe();\n        if (--this._subscriptionsCount === 0) {\n          this._invalidateCacheSoon();\n\n          for (const unsubscribe of this._unsubscribers) {\n            unsubscribe();\n          }\n        }\n      },\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/utils/cel-fields.d.ts

@@ -0,0 +1,23 @@
+//#region src/utils/cel-fields.d.ts
+type ConditionField = 'email' | 'countryCode' | 'emailDomain' | 'authMethod' | 'oauthProvider' | 'riskScores.bot' | 'riskScores.free_trial_abuse';
+type ConditionOperator = 'equals' | 'not_equals' | 'greater_than' | 'greater_or_equal' | 'less_than' | 'less_or_equal' | 'matches' | 'ends_with' | 'starts_with' | 'contains' | 'in_list';
+declare function isNumericField(field: ConditionField): boolean;
+/**
+ * Validates a numeric field value is a finite integer within [0, 100].
+ * Returns null if valid, or an error message string if invalid.
+ */
+declare function validateNumericFieldValue(field: string, value: string | number): string | null;
+declare function escapeCelString(value: string): string;
+declare function unescapeCelString(value: string): string;
+type FieldMetadataEntry = {
+  label: string;
+  operators: ConditionOperator[];
+  predefinedValues?: string[];
+};
+declare const fieldMetadata: Record<ConditionField, FieldMetadataEntry>;
+declare const conditionFields: ConditionField[];
+declare const conditionOperators: ConditionOperator[];
+declare function getOperatorsForField(field: ConditionField): ConditionOperator[];
+//#endregion
+export { ConditionField, ConditionOperator, FieldMetadataEntry, conditionFields, conditionOperators, escapeCelString, fieldMetadata, getOperatorsForField, isNumericField, unescapeCelString, validateNumericFieldValue };
+//# sourceMappingURL=cel-fields.d.ts.map

package/dist/utils/cel-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-fields.d.ts","names":[],"sources":["../../src/utils/cel-fields.ts"],"mappings":";KAKY,cAAA;AAAA,KASA,iBAAA;AAAA,iBAeI,cAAA,CAAe,KAAA,EAAO,cAAA;;;;AAftC;iBAuBgB,yBAAA,CAA0B,KAAA,UAAe,KAAA;AAAA,iBAczC,eAAA,CAAgB,KAAA;AAAA,iBAIhB,iBAAA,CAAkB,KAAA;AAAA,KAUtB,kBAAA;EACV,KAAA;EACA,SAAA,EAAW,iBAAA;EACX,gBAAA;AAAA;AAAA,cAGW,aAAA,EAAe,MAAA,CAAO,cAAA,EAAgB,kBAAA;AAAA,cAUtC,eAAA,EAAgD,cAAA;AAAA,cAEhD,kBAAA,EAAoB,iBAAA;AAAA,iBAMjB,oBAAA,CAAqB,KAAA,EAAO,cAAA,GAAiB,iBAAA"}

package/dist/utils/cel-fields.js

@@ -0,0 +1,108 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __auth_methods_js = require("./auth-methods.js");
+let __oauth_js = require("./oauth.js");
+
+//#region src/utils/cel-fields.ts
+function isNumericField(field) {
+	return field === "riskScores.bot" || field === "riskScores.free_trial_abuse";
+}
+/**
+* Validates a numeric field value is a finite integer within [0, 100].
+* Returns null if valid, or an error message string if invalid.
+*/
+function validateNumericFieldValue(field, value) {
+	const num = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(num)) return `Expected a finite number for field "${field}", got "${String(value)}"`;
+	if (!Number.isInteger(num)) return `Expected an integer for field "${field}", got "${String(value)}"`;
+	if (num < 0 || num > 100) return `Value for field "${field}" must be between 0 and 100, got ${num}`;
+	return null;
+}
+function escapeCelString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function unescapeCelString(value) {
+	return value.replace(/\\\\/g, "\\").replace(/\\"/g, "\"");
+}
+const numericOperators = [
+	"equals",
+	"not_equals",
+	"greater_than",
+	"greater_or_equal",
+	"less_than",
+	"less_or_equal"
+];
+const enumOperators = [
+	"equals",
+	"not_equals",
+	"in_list"
+];
+const stringOperators = [
+	"equals",
+	"not_equals",
+	"contains",
+	"starts_with",
+	"ends_with",
+	"matches",
+	"in_list"
+];
+const fieldMetadata = {
+	email: {
+		label: "Email",
+		operators: stringOperators
+	},
+	countryCode: {
+		label: "Country Code",
+		operators: enumOperators
+	},
+	emailDomain: {
+		label: "Email Domain",
+		operators: stringOperators
+	},
+	authMethod: {
+		label: "Auth Method",
+		operators: enumOperators,
+		predefinedValues: [...__auth_methods_js.signUpAuthMethodValues]
+	},
+	oauthProvider: {
+		label: "OAuth Provider",
+		operators: enumOperators,
+		predefinedValues: [...__oauth_js.standardProviders]
+	},
+	"riskScores.bot": {
+		label: "Risk Score: Bot",
+		operators: numericOperators
+	},
+	"riskScores.free_trial_abuse": {
+		label: "Risk Score: Free Trial Abuse",
+		operators: numericOperators
+	}
+};
+const conditionFields = Object.keys(fieldMetadata);
+const conditionOperators = [
+	"equals",
+	"not_equals",
+	"greater_than",
+	"greater_or_equal",
+	"less_than",
+	"less_or_equal",
+	"matches",
+	"ends_with",
+	"starts_with",
+	"contains",
+	"in_list"
+];
+function getOperatorsForField(field) {
+	return fieldMetadata[field].operators;
+}
+
+//#endregion
+exports.conditionFields = conditionFields;
+exports.conditionOperators = conditionOperators;
+exports.escapeCelString = escapeCelString;
+exports.fieldMetadata = fieldMetadata;
+exports.getOperatorsForField = getOperatorsForField;
+exports.isNumericField = isNumericField;
+exports.unescapeCelString = unescapeCelString;
+exports.validateNumericFieldValue = validateNumericFieldValue;
+//# sourceMappingURL=cel-fields.js.map

package/dist/utils/cel-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-fields.js","names":["signUpAuthMethodValues","standardProviders"],"sources":["../../src/utils/cel-fields.ts"],"sourcesContent":["import { signUpAuthMethodValues } from \"./auth-methods\";\nimport { standardProviders } from \"./oauth\";\n\n// ── Types ──────────────────────────────────────────────────────────────\n\nexport type ConditionField =\n  | 'email'\n  | 'countryCode'\n  | 'emailDomain'\n  | 'authMethod'\n  | 'oauthProvider'\n  | 'riskScores.bot'\n  | 'riskScores.free_trial_abuse';\n\nexport type ConditionOperator =\n  | 'equals'\n  | 'not_equals'\n  | 'greater_than'\n  | 'greater_or_equal'\n  | 'less_than'\n  | 'less_or_equal'\n  | 'matches'\n  | 'ends_with'\n  | 'starts_with'\n  | 'contains'\n  | 'in_list';\n\n// ── Helpers ────────────────────────────────────────────────────────────\n\nexport function isNumericField(field: ConditionField): boolean {\n  return field === 'riskScores.bot' || field === 'riskScores.free_trial_abuse';\n}\n\n/**\n * Validates a numeric field value is a finite integer within [0, 100].\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateNumericFieldValue(field: string, value: string | number): string | null {\n  const num = typeof value === 'number' ? value : Number(value);\n  if (!Number.isFinite(num)) {\n    return `Expected a finite number for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (!Number.isInteger(num)) {\n    return `Expected an integer for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (num < 0 || num > 100) {\n    return `Value for field \"${field}\" must be between 0 and 100, got ${num}`;\n  }\n  return null;\n}\n\nexport function escapeCelString(value: string): string {\n  return value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"');\n}\n\nexport function unescapeCelString(value: string): string {\n  return value.replace(/\\\\\\\\/g, '\\\\').replace(/\\\\\"/g, '\"');\n}\n\n// ── Field metadata ─────────────────────────────────────────────────────\n\nconst numericOperators: ConditionOperator[] = ['equals', 'not_equals', 'greater_than', 'greater_or_equal', 'less_than', 'less_or_equal'];\nconst enumOperators: ConditionOperator[] = ['equals', 'not_equals', 'in_list'];\nconst stringOperators: ConditionOperator[] = ['equals', 'not_equals', 'contains', 'starts_with', 'ends_with', 'matches', 'in_list'];\n\nexport type FieldMetadataEntry = {\n  label: string,\n  operators: ConditionOperator[],\n  predefinedValues?: string[],\n};\n\nexport const fieldMetadata: Record<ConditionField, FieldMetadataEntry> = {\n  email: { label: 'Email', operators: stringOperators },\n  countryCode: { label: 'Country Code', operators: enumOperators },\n  emailDomain: { label: 'Email Domain', operators: stringOperators },\n  authMethod: { label: 'Auth Method', operators: enumOperators, predefinedValues: [...signUpAuthMethodValues] },\n  oauthProvider: { label: 'OAuth Provider', operators: enumOperators, predefinedValues: [...standardProviders] },\n  'riskScores.bot': { label: 'Risk Score: Bot', operators: numericOperators },\n  'riskScores.free_trial_abuse': { label: 'Risk Score: Free Trial Abuse', operators: numericOperators },\n};\n\nexport const conditionFields = Object.keys(fieldMetadata) as ConditionField[];\n\nexport const conditionOperators: ConditionOperator[] = [\n  'equals', 'not_equals', 'greater_than', 'greater_or_equal',\n  'less_than', 'less_or_equal', 'matches', 'ends_with',\n  'starts_with', 'contains', 'in_list',\n];\n\nexport function getOperatorsForField(field: ConditionField): ConditionOperator[] {\n  return fieldMetadata[field].operators;\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,eAAe,OAAgC;AAC7D,QAAO,UAAU,oBAAoB,UAAU;;;;;;AAOjD,SAAgB,0BAA0B,OAAe,OAAuC;CAC9F,MAAM,MAAM,OAAO,UAAU,WAAW,QAAQ,OAAO,MAAM;AAC7D,KAAI,CAAC,OAAO,SAAS,IAAI,CACvB,QAAO,uCAAuC,MAAM,UAAU,OAAO,MAAM,CAAC;AAE9E,KAAI,CAAC,OAAO,UAAU,IAAI,CACxB,QAAO,kCAAkC,MAAM,UAAU,OAAO,MAAM,CAAC;AAEzE,KAAI,MAAM,KAAK,MAAM,IACnB,QAAO,oBAAoB,MAAM,mCAAmC;AAEtE,QAAO;;AAGT,SAAgB,gBAAgB,OAAuB;AACrD,QAAO,MAAM,QAAQ,OAAO,OAAO,CAAC,QAAQ,MAAM,OAAM;;AAG1D,SAAgB,kBAAkB,OAAuB;AACvD,QAAO,MAAM,QAAQ,SAAS,KAAK,CAAC,QAAQ,QAAQ,KAAI;;AAK1D,MAAM,mBAAwC;CAAC;CAAU;CAAc;CAAgB;CAAoB;CAAa;CAAgB;AACxI,MAAM,gBAAqC;CAAC;CAAU;CAAc;CAAU;AAC9E,MAAM,kBAAuC;CAAC;CAAU;CAAc;CAAY;CAAe;CAAa;CAAW;CAAU;AAQnI,MAAa,gBAA4D;CACvE,OAAO;EAAE,OAAO;EAAS,WAAW;EAAiB;CACrD,aAAa;EAAE,OAAO;EAAgB,WAAW;EAAe;CAChE,aAAa;EAAE,OAAO;EAAgB,WAAW;EAAiB;CAClE,YAAY;EAAE,OAAO;EAAe,WAAW;EAAe,kBAAkB,CAAC,GAAGA,yCAAuB;EAAE;CAC7G,eAAe;EAAE,OAAO;EAAkB,WAAW;EAAe,kBAAkB,CAAC,GAAGC,6BAAkB;EAAE;CAC9G,kBAAkB;EAAE,OAAO;EAAmB,WAAW;EAAkB;CAC3E,+BAA+B;EAAE,OAAO;EAAgC,WAAW;EAAkB;CACtG;AAED,MAAa,kBAAkB,OAAO,KAAK,cAAc;AAEzD,MAAa,qBAA0C;CACrD;CAAU;CAAc;CAAgB;CACxC;CAAa;CAAiB;CAAW;CACzC;CAAe;CAAY;CAC5B;AAED,SAAgB,qBAAqB,OAA4C;AAC/E,QAAO,cAAc,OAAO"}

package/dist/utils/compile-time.d.ts

@@ -0,0 +1,10 @@
+//#region src/utils/compile-time.d.ts
+/**
+ * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
+ * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
+ * to exist at runtime).
+ */
+declare function scrambleDuringCompileTime<T>(t: T): T;
+//#endregion
+export { scrambleDuringCompileTime };
+//# sourceMappingURL=compile-time.d.ts.map

package/dist/utils/compile-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-time.d.ts","names":[],"sources":["../../src/utils/compile-time.tsx"],"mappings":";;AAKA;;;;iBAAgB,yBAAA,GAAA,CAA6B,CAAA,EAAG,CAAA,GAAI,CAAA"}

package/dist/utils/compile-time.js

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/compile-time.tsx
+/**
+* Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
+* cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
+* to exist at runtime).
+*/
+function scrambleDuringCompileTime(t) {
+	if (Math.random() < 1e-5 && Math.random() > .99999 && Math.random() < 1e-5 && Math.random() > .99999) return "this will never happen";
+	return t;
+}
+
+//#endregion
+exports.scrambleDuringCompileTime = scrambleDuringCompileTime;
+//# sourceMappingURL=compile-time.js.map

package/dist/utils/compile-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-time.js","names":[],"sources":["../../src/utils/compile-time.tsx"],"sourcesContent":["/**\n * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some\n * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed\n * to exist at runtime).\n */\nexport function scrambleDuringCompileTime<T>(t: T): T {\n  if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {\n    return \"this will never happen\" as any;\n  }\n  return t;\n}\n"],"mappings":";;;;;;;;AAKA,SAAgB,0BAA6B,GAAS;AACpD,KAAI,KAAK,QAAQ,GAAG,QAAW,KAAK,QAAQ,GAAG,UAAW,KAAK,QAAQ,GAAG,QAAW,KAAK,QAAQ,GAAG,OACnG,QAAO;AAET,QAAO"}

package/dist/utils/country-codes.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/country-codes.d.ts
+declare function normalizeCountryCode(countryCode: string): string;
+declare function isValidCountryCode(countryCode: string): boolean;
+/**
+ * Validates and normalizes a country code value (single string or array).
+ * Returns null if valid, or an error message string if invalid.
+ */
+declare function validateCountryCode(value: string | string[]): string | null;
+//#endregion
+export { isValidCountryCode, normalizeCountryCode, validateCountryCode };
+//# sourceMappingURL=country-codes.d.ts.map

package/dist/utils/country-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"country-codes.d.ts","names":[],"sources":["../../src/utils/country-codes.ts"],"mappings":";iBAAgB,oBAAA,CAAqB,WAAA;AAAA,iBAIrB,kBAAA,CAAmB,WAAA;;;;;iBASnB,mBAAA,CAAoB,KAAA"}

package/dist/utils/country-codes.js

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/country-codes.ts
+function normalizeCountryCode(countryCode) {
+	return countryCode.trim().toUpperCase();
+}
+function isValidCountryCode(countryCode) {
+	const normalized = normalizeCountryCode(countryCode);
+	return /^[A-Z]{2}$/.test(normalized);
+}
+/**
+* Validates and normalizes a country code value (single string or array).
+* Returns null if valid, or an error message string if invalid.
+*/
+function validateCountryCode(value) {
+	const values = Array.isArray(value) ? value : [value];
+	if (values.length === 0) return "At least one country code is required";
+	return values.every((v) => isValidCountryCode(v)) ? null : "Country code must be a 2-letter code";
+}
+(void 0)?.test("country codes", ({ expect }) => {
+	expect(normalizeCountryCode(" us ")).toBe("US");
+	expect(isValidCountryCode("us")).toBe(true);
+	expect(isValidCountryCode("US")).toBe(true);
+	expect(isValidCountryCode("ZZ")).toBe(true);
+	expect(isValidCountryCode("usa")).toBe(false);
+	expect(isValidCountryCode("a")).toBe(false);
+	expect(isValidCountryCode("")).toBe(false);
+	expect(isValidCountryCode("12")).toBe(false);
+	expect(validateCountryCode("US")).toBeNull();
+	expect(validateCountryCode("zz")).toBeNull();
+	expect(validateCountryCode(["US", "CA"])).toBeNull();
+	expect(validateCountryCode([])).toBe("At least one country code is required");
+	expect(validateCountryCode(["US", "123"])).toBe("Country code must be a 2-letter code");
+});
+
+//#endregion
+exports.isValidCountryCode = isValidCountryCode;
+exports.normalizeCountryCode = normalizeCountryCode;
+exports.validateCountryCode = validateCountryCode;
+//# sourceMappingURL=country-codes.js.map

package/dist/utils/country-codes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"country-codes.js","names":[],"sources":["../../src/utils/country-codes.ts"],"sourcesContent":["export function normalizeCountryCode(countryCode: string): string {\n  return countryCode.trim().toUpperCase();\n}\n\nexport function isValidCountryCode(countryCode: string): boolean {\n  const normalized = normalizeCountryCode(countryCode);\n  return /^[A-Z]{2}$/.test(normalized);\n}\n\n/**\n * Validates and normalizes a country code value (single string or array).\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateCountryCode(value: string | string[]): string | null {\n  const values = Array.isArray(value) ? value : [value];\n  if (values.length === 0) {\n    return \"At least one country code is required\";\n  }\n  return values.every(v => isValidCountryCode(v))\n    ? null\n    : \"Country code must be a 2-letter code\";\n}\n\nimport.meta.vitest?.test(\"country codes\", ({ expect }) => {\n  expect(normalizeCountryCode(\" us \")).toBe(\"US\");\n  expect(isValidCountryCode(\"us\")).toBe(true);\n  expect(isValidCountryCode(\"US\")).toBe(true);\n  expect(isValidCountryCode(\"ZZ\")).toBe(true);\n  expect(isValidCountryCode(\"usa\")).toBe(false);\n  expect(isValidCountryCode(\"a\")).toBe(false);\n  expect(isValidCountryCode(\"\")).toBe(false);\n  expect(isValidCountryCode(\"12\")).toBe(false);\n\n  expect(validateCountryCode(\"US\")).toBeNull();\n  expect(validateCountryCode(\"zz\")).toBeNull();\n  expect(validateCountryCode([\"US\", \"CA\"])).toBeNull();\n  expect(validateCountryCode([])).toBe(\"At least one country code is required\");\n  expect(validateCountryCode([\"US\", \"123\"])).toBe(\"Country code must be a 2-letter code\");\n});\n"],"mappings":";;;AAAA,SAAgB,qBAAqB,aAA6B;AAChE,QAAO,YAAY,MAAM,CAAC,aAAa;;AAGzC,SAAgB,mBAAmB,aAA8B;CAC/D,MAAM,aAAa,qBAAqB,YAAY;AACpD,QAAO,aAAa,KAAK,WAAW;;;;;;AAOtC,SAAgB,oBAAoB,OAAyC;CAC3E,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;AACrD,KAAI,OAAO,WAAW,EACpB,QAAO;AAET,QAAO,OAAO,OAAM,MAAK,mBAAmB,EAAE,CAAA,GAC1C,OACA;;CAGN,SAAW,KAAC,kBAAsB,EAAA,aAAW;AAC3C,QAAO,qBAAqB,OAAO,CAAC,CAAC,KAAK,KAAK;AAC/C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,mBAAmB,MAAM,CAAC,CAAC,KAAK,MAAM;AAC7C,QAAO,mBAAmB,IAAI,CAAC,CAAC,KAAK,MAAM;AAC3C,QAAO,mBAAmB,GAAG,CAAC,CAAC,KAAK,MAAM;AAC1C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,MAAM;AAE5C,QAAO,oBAAoB,KAAK,CAAC,CAAC,UAAU;AAC5C,QAAO,oBAAoB,KAAK,CAAC,CAAC,UAAU;AAC5C,QAAO,oBAAoB,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,UAAU;AACpD,QAAO,oBAAoB,EAAE,CAAC,CAAC,CAAC,KAAK,wCAAwC;AAC7E,QAAO,oBAAoB,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,KAAK,uCAAuC;EACvF"}

package/dist/utils/crypto.d.ts

@@ -0,0 +1,48 @@
+//#region src/utils/crypto.d.ts
+declare function generateRandomValues(array: Uint8Array): typeof array;
+/**
+ * Generates a secure alphanumeric string using the system's cryptographically secure
+ * random number generator.
+ */
+declare function generateSecureRandomString(minBitsOfEntropy?: number): string;
+declare function encrypt({
+  purpose,
+  secret,
+  value
+}: {
+  purpose: string;
+  secret: string | Uint8Array;
+  value: Uint8Array;
+}): Promise<Uint8Array<ArrayBuffer>>;
+declare function decrypt({
+  purpose,
+  secret,
+  cipher
+}: {
+  purpose: string;
+  secret: string | Uint8Array;
+  cipher: Uint8Array;
+}): Promise<({
+  status: "ok";
+  data: Uint8Array<ArrayBuffer>;
+} & {
+  status: "ok";
+}) | ({
+  status: "error";
+  error: Error;
+} & {
+  status: "error";
+})>;
+type HashOptions = {
+  purpose: string;
+  salt?: string | Uint8Array;
+  extra?: string | Uint8Array;
+  value: string | Uint8Array;
+};
+declare function hash(options: HashOptions): Promise<Uint8Array<ArrayBuffer>>;
+declare function iteratedHash(options: HashOptions & {
+  iterations: number;
+}): Promise<Uint8Array<ArrayBuffer>>;
+//#endregion
+export { HashOptions, decrypt, encrypt, generateRandomValues, generateSecureRandomString, hash, iteratedHash };
+//# sourceMappingURL=crypto.d.ts.map

package/dist/utils/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","names":[],"sources":["../../src/utils/crypto.tsx"],"mappings":";iBAMgB,oBAAA,CAAqB,KAAA,EAAO,UAAA,UAAoB,KAAA;AAAhE;;;;AAAA,iBAcgB,0BAAA,CAA2B,gBAAA;AAAA,iBA8BrB,OAAA,CAAA;EAAU,OAAA;EAAS,MAAA;EAAQ;AAAA;EAAW,OAAA;EAAiB,MAAA,WAAiB,UAAA;EAAY,KAAA,EAAO,UAAA;AAAA,IAAY,OAAA,CAAA,UAAA,CAAA,WAAA;AAAA,iBAcvG,OAAA,CAAA;EAAU,OAAA;EAAS,MAAA;EAAQ;AAAA;EAAY,OAAA;EAAiB,MAAA,WAAiB,UAAA;EAAY,MAAA,EAAQ,UAAA;AAAA,IAAY,OAAA;;;;;;;;;;;KAyCnH,WAAA;EACV,OAAA;EACA,IAAA,YAAgB,UAAA;EAChB,KAAA,YAAiB,UAAA;EACjB,KAAA,WAAgB,UAAA;AAAA;AAAA,iBAGI,IAAA,CAAK,OAAA,EAAS,WAAA,GAAW,OAAA,CAAA,UAAA,CAAA,WAAA;AAAA,iBAIzB,YAAA,CAAa,OAAA,EAAS,WAAA;EAAgB,UAAA;AAAA,IAAoB,OAAA,CAAA,UAAA,CAAA,WAAA"}