@vuetify/v0 0.1.2 → 0.1.4

package/dist/createTokens-BlhLdHXE.mjs

@@ -0,0 +1,682 @@
+import { d as isObject, h as isUndefined, p as isString, t as clamp, v as useId$1 } from "./utilities-BqS1sC1W.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-EeHQSsb6.mjs";
+import { i as useLogger } from "./useLogger-CO9JwbSJ.mjs";
+import { shallowReactive } from "vue";
+
+//#region src/composables/createRegistry/index.ts
+/**
+* @module createRegistry
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-registry
+*
+* @remarks
+* A foundational composable for managing collections of items (tickets) with:
+* - Unique ID-based access
+* - Index-based ordering
+* - Value-based reverse lookup
+* - Automatic reindexing
+* - Optional event emission
+* - Performance-optimized caching
+*
+* The registry serves as the base for many other composables in the system,
+* including useSelection, useForm, useTimeline, and more.
+*/
+/**
+* Creates a new registry instance.
+*
+* @param options The options for the registry instance.
+* @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+* @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+* @returns A new registry instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-registry#create-registry
+*
+* @example
+* ```ts
+* import { createRegistry } from '@vuetify/v0'
+*
+* const registry = createRegistry()
+*
+* const ticket1 = registry.register({ id: 'user-1', value: { name: 'John' } })
+* const ticket2 = registry.register({ id: 'user-2', value: { name: 'Jane' } })
+*
+* console.log(registry.size) // 2
+* console.log(registry.get('user-1')) // { id: 'user-1', index: 0, value: { name: 'John' }, ... }
+* ```
+*/
+function createRegistry(options) {
+	const logger = useLogger();
+	const events = options?.events ?? false;
+	const reactive$1 = options?.reactive ?? false;
+	const collection = reactive$1 ? shallowReactive(/* @__PURE__ */ new Map()) : /* @__PURE__ */ new Map();
+	const catalog = /* @__PURE__ */ new Map();
+	const directory = /* @__PURE__ */ new Map();
+	const cache = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	let indexDependentCount = 0;
+	let needsReindex = false;
+	let minDirtyIndex = Infinity;
+	let batching = false;
+	let batched = [];
+	function dispatch(event, data) {
+		const cbs = listeners.get(event);
+		if (!cbs) return;
+		for (const cb of cbs) cb(data);
+	}
+	function emit(event, data = void 0) {
+		if (!events) return;
+		if (batching) {
+			batched.push({
+				event,
+				data
+			});
+			return;
+		}
+		dispatch(event, data);
+	}
+	function on(event, cb) {
+		if (!events) {
+			logger.warn(`Events are disabled. Initialize with \`createRegistry({ events: true })\` to enable.`);
+			return;
+		}
+		if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+		listeners.get(event).add(cb);
+	}
+	function off(event, cb) {
+		if (!events) {
+			logger.warn(`Events are disabled. Initialize with \`createRegistry({ events: true })\` to enable.`);
+			return;
+		}
+		listeners.get(event)?.delete(cb);
+	}
+	function dispose() {
+		listeners.clear();
+		clear();
+	}
+	function get(id) {
+		return collection.get(id);
+	}
+	function upsert(id, patch = {}) {
+		const existing = get(id);
+		if (!existing) return register({
+			...patch,
+			id
+		});
+		const hasValue = Object.prototype.hasOwnProperty.call(patch, "value");
+		let value = existing.value;
+		let valueIsIndex = existing.valueIsIndex;
+		if (hasValue) {
+			if (/* @__PURE__ */ isUndefined(patch.value)) {
+				value = existing.index;
+				valueIsIndex = true;
+			} else {
+				value = patch.value;
+				valueIsIndex = false;
+			}
+			if (valueIsIndex !== existing.valueIsIndex) if (valueIsIndex) indexDependentCount++;
+			else indexDependentCount--;
+			if (!Object.is(value, existing.value)) {
+				unassign(existing.value, id);
+				assign(value, id);
+			}
+		}
+		const updated = {
+			...existing,
+			...patch,
+			id,
+			index: existing.index,
+			value,
+			valueIsIndex
+		};
+		collection.set(id, updated);
+		invalidate();
+		emit("update:ticket", updated);
+		return updated;
+	}
+	function browse(value) {
+		if (needsReindex) reindex();
+		return catalog.get(value);
+	}
+	function lookup(index) {
+		if (needsReindex) reindex();
+		return directory.get(index);
+	}
+	function has(id) {
+		return collection.has(id);
+	}
+	function assign(value, id) {
+		const bucket = catalog.get(value);
+		if (bucket) {
+			if (!bucket.includes(id)) bucket.push(id);
+		} else catalog.set(value, [id]);
+	}
+	function unassign(value, id) {
+		const bucket = catalog.get(value);
+		if (!bucket) return;
+		const next = bucket.filter((v) => v !== id);
+		if (next.length === 0) catalog.delete(value);
+		else catalog.set(value, next);
+	}
+	function keys() {
+		const cached = cache.get("keys");
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const keys$1 = Array.from(collection.keys());
+		cache.set("keys", keys$1);
+		return keys$1;
+	}
+	function values() {
+		const cached = cache.get("values");
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const values$1 = Array.from(collection.values());
+		cache.set("values", values$1);
+		return values$1;
+	}
+	function entries() {
+		const cached = cache.get("entries");
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const entries$1 = Array.from(collection.entries());
+		cache.set("entries", entries$1);
+		return entries$1;
+	}
+	function clear() {
+		collection.clear();
+		catalog.clear();
+		directory.clear();
+		invalidate();
+		indexDependentCount = 0;
+		needsReindex = false;
+		minDirtyIndex = Infinity;
+		emit("clear:registry");
+	}
+	function invalidate() {
+		if (batching) return;
+		cache.clear();
+	}
+	function batch(fn) {
+		if (batching) return fn();
+		batching = true;
+		batched = [];
+		try {
+			const result = fn();
+			cache.clear();
+			for (const { event, data } of batched) dispatch(event, data);
+			return result;
+		} finally {
+			batching = false;
+			batched = [];
+		}
+	}
+	function reindex() {
+		const startIndex = minDirtyIndex === Infinity ? 0 : minDirtyIndex;
+		if (startIndex === 0) {
+			catalog.clear();
+			directory.clear();
+		}
+		invalidate();
+		let index = 0;
+		for (const ticket of collection.values()) {
+			if (index < startIndex) {
+				index++;
+				continue;
+			}
+			if (startIndex > 0) directory.delete(ticket.index);
+			if (ticket.valueIsIndex) {
+				if (startIndex > 0) unassign(ticket.value, ticket.id);
+				ticket.value = index;
+				assign(ticket.value, ticket.id);
+			} else if (startIndex === 0) assign(ticket.value, ticket.id);
+			ticket.index = index;
+			directory.set(index, ticket.id);
+			index++;
+		}
+		needsReindex = false;
+		minDirtyIndex = Infinity;
+		emit("reindex:registry");
+	}
+	function register(registration = {}) {
+		const size = collection.size;
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
+		if (has(id)) {
+			logger.warn(`Ticket "${id}" already exists. Use \`upsert()\` to update or check \`has()\` before registering.`);
+			return get(id);
+		}
+		const valueIsUndefined = /* @__PURE__ */ isUndefined(registration.value);
+		const index = registration.index ?? size;
+		const value = valueIsUndefined ? index : registration.value;
+		const valueIsIndex = valueIsUndefined;
+		if (valueIsIndex) indexDependentCount++;
+		const rawTicket = {
+			...registration,
+			id,
+			index,
+			value,
+			valueIsIndex
+		};
+		const ticket = reactive$1 ? shallowReactive(rawTicket) : rawTicket;
+		collection.set(ticket.id, ticket);
+		directory.set(ticket.index, ticket.id);
+		assign(ticket.value, ticket.id);
+		invalidate();
+		emit("register:ticket", ticket);
+		return ticket;
+	}
+	function unregister(id) {
+		const ticket = collection.get(id);
+		if (!ticket) return;
+		if (ticket.valueIsIndex) indexDependentCount--;
+		collection.delete(ticket.id);
+		directory.delete(ticket.index);
+		unassign(ticket.value, ticket.id);
+		const willReindex = indexDependentCount > 0 && ticket.index < collection.size;
+		if (!willReindex) invalidate();
+		emit("unregister:ticket", ticket);
+		minDirtyIndex = Math.min(minDirtyIndex, ticket.index);
+		if (willReindex) reindex();
+		else needsReindex = true;
+	}
+	function offboard(ids) {
+		batch(() => {
+			const removed = [];
+			for (const id of ids) {
+				const ticket = collection.get(id);
+				if (!ticket) continue;
+				if (ticket.valueIsIndex) indexDependentCount--;
+				minDirtyIndex = Math.min(minDirtyIndex, ticket.index);
+				collection.delete(ticket.id);
+				directory.delete(ticket.index);
+				unassign(ticket.value, ticket.id);
+				removed.push(ticket);
+			}
+			if (removed.length === 0) return;
+			for (const ticket of removed) emit("unregister:ticket", ticket);
+			needsReindex = true;
+		});
+	}
+	function seek(direction = "first", from, predicate) {
+		if (collection.size === 0) return void 0;
+		if (needsReindex) reindex();
+		if (!predicate && /* @__PURE__ */ isUndefined(from)) {
+			const tickets$1 = values();
+			return direction === "first" ? tickets$1[0] : tickets$1.at(-1);
+		}
+		const tickets = values();
+		const index = /* @__PURE__ */ isUndefined(from) ? void 0 : /* @__PURE__ */ clamp(from, 0, tickets.length - 1);
+		if (direction === "last") {
+			const start = /* @__PURE__ */ isUndefined(index) ? tickets.length - 1 : index;
+			for (let i = start; i >= 0; i--) {
+				const ticket = tickets[i];
+				if (!predicate || predicate(ticket)) return ticket;
+			}
+		} else {
+			const start = /* @__PURE__ */ isUndefined(index) ? 0 : index;
+			for (let i = start; i < tickets.length; i++) {
+				const ticket = tickets[i];
+				if (!predicate || predicate(ticket)) return ticket;
+			}
+		}
+	}
+	return {
+		collection,
+		emit,
+		on,
+		off,
+		dispose,
+		has,
+		keys,
+		clear,
+		browse,
+		entries,
+		values,
+		lookup,
+		get,
+		upsert,
+		register,
+		unregister,
+		reindex,
+		seek,
+		batch,
+		onboard(registrations) {
+			return batch(() => registrations.map((registration) => register(registration)));
+		},
+		offboard,
+		get size() {
+			return collection.size;
+		}
+	};
+}
+/**
+* Creates a new registry context.
+*
+* @param options The options for the registry context, including `namespace` (defaults to `'v0:registry'`) and `events`.
+* @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+* @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+* @returns A new registry context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-registry#create-registry-context
+*
+* @example
+* ```ts
+* import { createRegistryContext } from '@vuetify/v0'
+*
+* // With default namespace 'v0:registry'
+* export const [useItems, provideItems, items] = createRegistryContext()
+*
+* // Or with custom namespace
+* export const [useItems, provideItems, items] = createRegistryContext({ namespace: 'my-items' })
+*
+* // In a parent component:
+* provideItems()
+*
+* // In a child component:
+* const items = useItems()
+* items.register({ id: 'item-1', value: 'Value 1' })
+* ```
+*/
+function createRegistryContext(_options = {}) {
+	const { namespace = "v0:registry", ...options } = _options;
+	const [useRegistryContext, _provideRegistryContext] = createContext(namespace);
+	const context = createRegistry(options);
+	function provideRegistryContext(_context = context, app) {
+		return _provideRegistryContext(_context, app);
+	}
+	return createTrinity(useRegistryContext, provideRegistryContext, context);
+}
+/**
+* Uses an existing registry from context.
+*
+* @param namespace The namespace for the registry context. Defaults to `'v0:registry'`.
+* @template Z The type of registry ticket that extends RegistryTicket.
+* @template E The type of registry context that extends RegistryContext<Z>.
+* @returns The registry instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-registry#use-registry
+*
+* @example
+* ```ts
+* import { useRegistry } from '@vuetify/v0'
+*
+* // In a child component (after provideRegistry was called by an ancestor):
+* const registry = useRegistry()
+*
+* registry.register({ id: 'item-1', value: 'Value 1' })
+* ```
+*/
+function useRegistry(namespace = "v0:registry") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/createTokens/index.ts
+/**
+* @module createTokens
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-tokens
+*
+* @remarks
+* Design token registry with alias resolution and W3C Design Tokens format support.
+*
+* Key features:
+* - Alias resolution with circular reference detection
+* - Nested token flattening with dot notation
+* - W3C Design Tokens format ($value, $type, $description, $extensions)
+* - Path-based resolution (e.g., {colors}.blue.500)
+* - Resolution caching for performance (~28,590 ops/sec)
+*
+* Used by useTheme, useLocale, and useFeatures for token-based configuration.
+*/
+/**
+* Creates a new token instance.
+*
+* @param tokens The tokens to use.
+* @param options The options for the token instance.
+* @template Z The type of the token ticket.
+* @template E The type of the token context.
+* @returns A new token instance.
+*
+* @see https://www.designtokens.org/tr/drafts/format/
+* @see https://0.vuetifyjs.com/composables/registration/create-tokens
+*
+* @example
+* ```ts
+* import { createTokens } from '@vuetify/v0'
+*
+* const tokens = createTokens({
+*   colors: {
+*     primary: '#3b82f6',
+*     secondary: '{colors.primary}', // Alias reference
+*   },
+* })
+*
+* console.log(tokens.resolve('{colors.primary}')) // '#3b82f6'
+* console.log(tokens.resolve('{colors.secondary}')) // '#3b82f6'
+* ```
+*/
+function createTokens(tokens = {}, options = {}) {
+	const logger = useLogger();
+	const registry = createRegistry(options);
+	const cache = /* @__PURE__ */ new Map();
+	registry.onboard(flatten(tokens, options.prefix, !!options.flat));
+	function isAlias(token) {
+		return /* @__PURE__ */ isString(token) && token.length > 2 && token[0] === "{" && token.at(-1) === "}";
+	}
+	function isTokenAlias(value) {
+		return /* @__PURE__ */ isObject(value) && "$value" in value;
+	}
+	function resolve(token, visited = /* @__PURE__ */ new Set()) {
+		const cacheKey = /* @__PURE__ */ isString(token) ? token : JSON.stringify(token);
+		const cached = cache.get(cacheKey);
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
+		const reference = isTokenAlias(token) ? token.$value : token;
+		const isAliasReference = /* @__PURE__ */ isString(reference) && isAlias(reference);
+		const clean = isAliasReference ? reference.slice(1, -1) : String(reference);
+		if (visited.has(clean)) {
+			logger.warn(`Circular alias detected for "${clean}"`);
+			cache.set(cacheKey, void 0);
+			return;
+		}
+		visited.add(clean);
+		let found = registry.get(clean);
+		let segments = [];
+		if (!found && clean.includes(".")) {
+			const parts = clean.split(".");
+			for (let i = parts.length - 1; i > 0; i--) {
+				const prefix = parts.slice(0, i).join(".");
+				const suffix = parts.slice(i);
+				const candidate = registry.get(prefix);
+				if (!/* @__PURE__ */ isUndefined(candidate?.value)) {
+					found = candidate;
+					segments = suffix;
+					break;
+				}
+			}
+		}
+		if (/* @__PURE__ */ isUndefined(found?.value)) {
+			if (isAliasReference) logger.warn(`Alias not found for "${String(reference)}"`);
+			cache.set(cacheKey, void 0);
+			return;
+		}
+		let result;
+		let current = found.value;
+		if (segments.length > 0) {
+			if (isTokenAlias(current)) current = current.$value;
+			for (const segment of segments) {
+				if (!/* @__PURE__ */ isObject(current) || !(segment in current)) {
+					current = void 0;
+					break;
+				}
+				current = current[segment];
+				if (isTokenAlias(current)) current = current.$value;
+			}
+			if (/* @__PURE__ */ isUndefined(current)) {
+				logger.warn(`Path not found inside "${clean}": ${segments.join(".")}`);
+				cache.set(cacheKey, void 0);
+				return;
+			}
+			result = current;
+		} else if (isTokenAlias(current)) {
+			const inner = current.$value;
+			if (/* @__PURE__ */ isString(inner) && isAlias(inner)) return resolve(inner, visited);
+			result = inner;
+		} else if (/* @__PURE__ */ isString(current) && isAlias(current)) return resolve(current, visited);
+		else result = current;
+		cache.set(cacheKey, result);
+		return result;
+	}
+	const { register: _register, upsert: _upsert, unregister: _unregister } = registry;
+	function register(registration) {
+		cache.clear();
+		return _register(registration);
+	}
+	function upsert(id, registration) {
+		cache.clear();
+		return _upsert(id, registration);
+	}
+	function unregister(id) {
+		cache.clear();
+		return _unregister(id);
+	}
+	return {
+		...registry,
+		register,
+		upsert,
+		unregister,
+		resolve,
+		isAlias,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new token context.
+*
+* @param namespace The namespace for the token context.
+* @param tokens The tokens to use.
+* @template Z The type of the token ticket.
+* @template E The type of the token context.
+* @returns A new token context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-tokens
+*
+* @example
+* ```ts
+* import { createTokensContext } from '@vuetify/v0'
+*
+* export const [useTokens, provideTokens, context] = createTokensContext({
+*  namespace: 'v0:tokens',
+*  tokens: {
+*    colors: {
+*      primary: '#3b82f6',
+*      secondary: '{colors.primary}', // Alias reference
+*    },
+*  },
+* })
+* ```
+*/
+function createTokensContext(_options) {
+	const { namespace = "v0:tokens", tokens = {}, ...options } = _options;
+	const [useTokensContext, _provideTokensContext] = createContext(namespace);
+	const context = createTokens(tokens, options);
+	function provideTokensContext(_context = context, app) {
+		return _provideTokensContext(_context, app);
+	}
+	return createTrinity(useTokensContext, provideTokensContext, context);
+}
+/**
+* Returns the current tokens instance.
+*
+* @param namespace The namespace for the tokens context. Defaults to `'v0:tokens'`.
+* @returns The current tokens instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-tokens
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useTokens } from '@vuetify/v0'
+*
+*   const tokens = useTokens()
+* <\/script>
+* ```
+*/
+function useTokens(namespace = "v0:tokens") {
+	return useContext(namespace);
+}
+/**
+* Flattens a nested collection of tokens into a flat array of tokens.
+* Each token is represented by an object containing its ID & value.
+* @param tokens The collection of tokens to flatten.
+* @param prefix An optional prefix to prepend to each token ID.
+* @returns An array of flattened tokens, each with an ID and value.
+*/
+function flatten(tokens, prefix = "", flat = false) {
+	const flattened = [];
+	const stack = [{
+		tokens,
+		prefix,
+		flat
+	}];
+	while (stack.length > 0) {
+		const { tokens: currentTokens, prefix: currentPrefix, flat: flat$1 } = stack.pop();
+		const meta = {};
+		for (const k in currentTokens) if (k.startsWith("$")) meta[k] = currentTokens[k];
+		if (Object.keys(meta).length > 0 && currentPrefix) flattened.push({
+			id: currentPrefix,
+			value: meta
+		});
+		for (const key in currentTokens) {
+			if (key.startsWith("$")) continue;
+			const value = currentTokens[key];
+			const id = currentPrefix ? `${currentPrefix}.${key}` : key;
+			if (!/* @__PURE__ */ isObject(value)) {
+				flattened.push({
+					id,
+					value
+				});
+				continue;
+			}
+			if ("$value" in value) {
+				flattened.push({
+					id,
+					value
+				});
+				const inner = value.$value;
+				if (/* @__PURE__ */ isObject(inner) && !flat$1) for (const innerKey in inner) {
+					if (innerKey.startsWith("$")) continue;
+					const child = inner[innerKey];
+					const childId = `${id}.${innerKey}`;
+					if (!/* @__PURE__ */ isObject(child)) flattened.push({
+						id: childId,
+						value: child
+					});
+					else if ("$value" in child) flattened.push({
+						id: childId,
+						value: child
+					});
+					else stack.push({
+						tokens: child,
+						prefix: childId,
+						flat: flat$1
+					});
+				}
+				continue;
+			}
+			if (flat$1) {
+				flattened.push({
+					id,
+					value
+				});
+				continue;
+			}
+			stack.push({
+				tokens: value,
+				prefix: id,
+				flat: flat$1
+			});
+		}
+	}
+	return flattened;
+}
+
+//#endregion
+export { createRegistryContext as a, createRegistry as i, createTokensContext as n, useRegistry as o, useTokens as r, createTokens as t };