@vuetify/v0 0.1.2 → 0.1.4

package/dist/useFeatures-C4JF3Hgr.mjs

@@ -0,0 +1,122 @@
+import { d as isObject, i as isBoolean, o as isFunction, r as isArray } from "./utilities-BqS1sC1W.mjs";
+import { o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
+import { t as createTokens } from "./createTokens-BlhLdHXE.mjs";
+import { t as createGroup } from "./createGroup-CPhp6FUh.mjs";
+
+//#region src/composables/useFeatures/adapters/generic/index.ts
+var FeaturesAdapter = class {};
+
+//#endregion
+//#region src/composables/useFeatures/index.ts
+/**
+* @module useFeatures
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-features
+*
+* @remarks
+* Feature flag system with boolean and token-based features.
+*
+* Key features:
+* - Boolean features (true/false activation)
+* - Token features with $variation support
+* - Auto-selection of enabled features
+* - Multi-select support for feature combinations
+* - Perfect for A/B testing, progressive rollout, feature toggles
+* - Adapter pattern for external feature flag services
+*
+* Inheritance chain: useRegistry → createSelection → createGroup → createFeatures
+* Integrates with useTokens for token-based features.
+*/
+/**
+* Creates a new features instance.
+*
+* @param options The options for the features instance.
+* @template Z The type of the feature ticket.
+* @template E The type of the feature context.
+* @returns A new features instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-features
+*
+* @example
+* ```ts
+* import { createFeatures } from '@vuetify/v0'
+*
+* const [useFeatures, provideFeaturesContext, context] = createFeatures({
+*   namespace: 'v0:features',
+*   features: {
+*     'dark-mode': true,
+*     'theme-color': { $variation: 'blue' },
+*   },
+* })
+* ```
+*/
+function createFeatures(_options = {}) {
+	const { features, ...options } = _options;
+	const tokens = createTokens(features, { flat: true });
+	const registry = createGroup({
+		...options,
+		reactive: true
+	});
+	for (const [id, { value }] of tokens.entries()) register({
+		id,
+		value
+	});
+	function variation(id, fallback = null) {
+		const ticket = registry.get(id);
+		if (!ticket) return fallback;
+		return /* @__PURE__ */ isObject(ticket.value) ? ticket.value.$variation ?? fallback : ticket.value ?? fallback;
+	}
+	function register(registration = {}) {
+		const item = {
+			value: false,
+			...registration
+		};
+		const ticket = registry.register(item);
+		if (/* @__PURE__ */ isBoolean(ticket.value) && ticket.value === true || /* @__PURE__ */ isObject(ticket.value) && /* @__PURE__ */ isBoolean(ticket.value.$value) && ticket.value.$value === true) registry.select(ticket.id);
+		return ticket;
+	}
+	function sync(flags) {
+		for (const [id, value] of Object.entries(flags)) if (registry.get(id)) {
+			const shouldSelect = /* @__PURE__ */ isBoolean(value) ? value === true : /* @__PURE__ */ isObject(value) && /* @__PURE__ */ isBoolean(value.$value) && value.$value === true;
+			registry.upsert(id, { value });
+			if (shouldSelect) registry.select(id);
+			else registry.unselect(id);
+		} else register({
+			id,
+			value
+		});
+	}
+	function onboard(registrations) {
+		return registry.batch(() => registrations.map((registration) => register(registration)));
+	}
+	return {
+		...registry,
+		variation,
+		register,
+		onboard,
+		sync,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+function createFeaturesFallback() {
+	return {
+		size: 0,
+		variation: (_id, fallback = null) => fallback,
+		sync: () => {}
+	};
+}
+const [createFeaturesContext, createFeaturesPlugin, useFeatures] = createPluginContext("v0:features", (options) => createFeatures(options), {
+	fallback: () => createFeaturesFallback(),
+	setup: (context, app, { adapter }) => {
+		if (!adapter) return;
+		for (const a of /* @__PURE__ */ isArray(adapter) ? adapter : [adapter]) {
+			context.sync(a.setup((flags) => context.sync(flags)));
+			if (/* @__PURE__ */ isFunction(a.dispose)) app.onUnmount(() => a.dispose());
+		}
+	}
+});
+
+//#endregion
+export { FeaturesAdapter as a, useFeatures as i, createFeaturesContext as n, createFeaturesPlugin as r, createFeatures as t };

package/dist/useLocale-DlbShzF-.mjs

@@ -0,0 +1,85 @@
+import { p as isString } from "./utilities-BqS1sC1W.mjs";
+import { o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
+import { t as createTokens } from "./createTokens-BlhLdHXE.mjs";
+import { t as createSingle } from "./createSingle-B59ya3aa.mjs";
+import { t as toArray } from "./toArray-DIeXVX1C.mjs";
+import { t as Vuetify0LocaleAdapter } from "./v0-BtQCSBOG.mjs";
+
+//#region src/composables/useLocale/index.ts
+/**
+* @module useLocale
+*
+* @remarks
+* Internationalization (i18n) composable with adapter pattern for message translation.
+*
+* Key features:
+* - Locale selection with createSingle
+* - Token-based message storage with useTokens
+* - Numbered and named placeholder support ({0}, {name})
+* - Number formatting with Intl.NumberFormat
+* - Adapter pattern for integration with i18n providers
+*
+* Integrates with createSingle for locale selection and useTokens for message resolution.
+*/
+/**
+* Creates a new locale instance.
+*
+* @param options The options for the locale instance.
+* @template Z The type of the locale ticket.
+* @template E The type of the locale context.
+* @returns A new locale instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-locale
+*/
+function createLocale(_options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {}, ...options } = _options;
+	const tokens = createTokens(messages);
+	const registry = createSingle(options);
+	for (const id in messages) {
+		registry.register({ id });
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	function t(key, params, fallback) {
+		const locale = registry.selectedId.value;
+		const args = toArray(params);
+		if (!locale) return adapter.t(fallback ?? key, ...args);
+		const path = `${locale}.${key}`;
+		const message = tokens.get(path)?.value;
+		const template = /* @__PURE__ */ isString(message) ? resolve(locale, message) : fallback ?? key;
+		return adapter.t(template, ...args);
+	}
+	function n(value, ...params) {
+		return adapter.n(value, registry.selectedId.value, ...params);
+	}
+	function resolve(locale, str, visited = /* @__PURE__ */ new Set()) {
+		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, key) => {
+			const [prefix, ...rest] = key.split(".");
+			const target = registry.has(prefix) ? prefix : locale;
+			const path = `${target}.${registry.has(prefix) ? rest.join(".") : key}`;
+			if (visited.has(path)) return match;
+			visited.add(path);
+			const resolved = tokens.get(path)?.value;
+			if (/* @__PURE__ */ isString(resolved)) return resolve(target, resolved, visited);
+			return match;
+		});
+	}
+	return {
+		...registry,
+		t,
+		n,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+function createLocaleFallback() {
+	return {
+		size: 0,
+		t: (key, _params, fallback) => fallback ?? key,
+		n: String
+	};
+}
+const [createLocaleContext, createLocalePlugin, useLocale] = createPluginContext("v0:locale", (options) => createLocale(options), { fallback: () => createLocaleFallback() });
+
+//#endregion
+export { useLocale as a, createLocalePlugin as i, createLocaleContext as n, createLocaleFallback as r, createLocale as t };

package/dist/useLogger-CO9JwbSJ.mjs

@@ -0,0 +1,283 @@
+import { s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-B_GVfG06.mjs";
+import { h as isUndefined } from "./utilities-BqS1sC1W.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-EeHQSsb6.mjs";
+import { t as Vuetify0LoggerAdapter } from "./v0-CtjuUUPl.mjs";
+import { hasInjectionContext } from "vue";
+
+//#region src/composables/createPlugin/index.ts
+/**
+* @module createPlugin
+*
+* @see https://vuejs.org/guide/reusability/plugins.html
+* @see https://0.vuetifyjs.com/composables/foundation/create-plugin
+*
+* @remarks
+* Factory for creating Vue plugins with proper context provision.
+*
+* Wraps the provide function in app.runWithContext() to ensure proper execution context,
+* allowing plugins to safely provide dependency injection contexts at the application level.
+*
+* Also exports `createPluginContext` — a higher-level factory that generates the standard
+* context/plugin/consumer triple for plugin composables, eliminating boilerplate.
+*/
+const INSTALLED = Symbol.for("v0:installed-plugins");
+function getInstalled(app) {
+	const ctx = app._context;
+	return ctx[INSTALLED] ??= /* @__PURE__ */ new Set();
+}
+/**
+* Creates a new Vue plugin.
+*
+* @param options The plugin options.
+* @returns A new Vue plugin.
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-plugin#create-plugin
+*
+* @example
+* ```ts
+* export const [useContext, provideContext] = createContext<MyContext>('my-plugin')
+*
+* const context = {}
+*
+* export const MyPlugin = createPlugin({
+*   namespace: 'my-plugin',
+*   provide: (app) => {
+*     provideContext(context, app)
+*   },
+*   setup: (app) => {
+*     // Optional setup logic
+*   },
+* })
+*/
+function createPlugin(options) {
+	return { install(app) {
+		app.runWithContext(() => {
+			options.provide(app);
+			const installed = getInstalled(app);
+			if (installed.has(options.namespace)) return;
+			installed.add(options.namespace);
+			options.setup?.(app);
+		});
+	} };
+}
+/**
+* Creates the three standard functions for a plugin composable.
+*
+* @param defaultNamespace The default DI namespace string (e.g. `'v0:logger'`).
+* @param factory Function that creates the composable context instance from options.
+* @param config Optional setup callback and fallback factory.
+* @returns A readonly tuple: `[createXContext, createXPlugin, useX]`.
+*
+* @example
+* ```ts
+* // Simple — no setup or fallback
+* export const [createStorageContext, createStoragePlugin, useStorage] =
+*   createPluginContext('v0:storage', options => createStorage(options))
+*
+* // With fallback — safe outside component instances
+* export const [createLoggerContext, createLoggerPlugin, useLogger] =
+*   createPluginContext('v0:logger', options => createLogger(options), {
+*     fallback: ns => createFallbackLogger(ns),
+*     setup: (context) => {
+*       if (__DEV__ && IN_BROWSER) (window as any).__v0Logger__ = context
+*     },
+*   })
+* ```
+*/
+function createPluginContext(defaultNamespace, factory, config) {
+	function createXContext(_options = {}) {
+		const { namespace = defaultNamespace, ...options } = _options;
+		const [_use, _provide] = createContext(namespace);
+		const context = factory(options);
+		function provide$1(_context = context, app) {
+			return _provide(_context, app);
+		}
+		return createTrinity(_use, provide$1, context);
+	}
+	function createXPlugin(_options = {}) {
+		const { namespace = defaultNamespace, ...options } = _options;
+		const [, provide$1, context] = createXContext({
+			...options,
+			namespace
+		});
+		return createPlugin({
+			namespace,
+			provide: (app) => {
+				provide$1(context, app);
+			},
+			setup: config?.setup ? (app) => config.setup(context, app, options) : void 0
+		});
+	}
+	function useX(namespace = defaultNamespace) {
+		if (config?.fallback) {
+			const instance = config.fallback(namespace);
+			if (!hasInjectionContext()) return instance;
+			return useContext(namespace, instance);
+		}
+		return useContext(namespace);
+	}
+	return [
+		createXContext,
+		createXPlugin,
+		useX
+	];
+}
+
+//#endregion
+//#region src/composables/useLogger/index.ts
+/**
+* @module useLogger
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @remarks
+* Logging composable with adapter pattern supporting console, consola, and pino.
+*
+* Key features:
+* - Multiple log levels (trace, debug, info, warn, error, fatal)
+* - Adapter pattern for console/consola/pino integration
+* - Enable/disable logging
+* - Fallback logger for undefined loggers
+* - Context logging support
+*
+* Uses adapter pattern to abstract logging implementation.
+*/
+/**
+* Creates a new logger instance.
+*
+* @param options The options for the logger instance.
+* @returns A new logger instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @example
+* ```ts
+* import { createLogger } from '@vuetify/v0'
+*
+* const logger = createLogger({
+*   level: 'debug',
+*   prefix: '[MyApp]',
+* })
+*
+* logger.info('This is an info message')
+* logger.debug('This is a debug message')
+* logger.error('This is an error message')
+* logger.level('debug')
+* logger.debug('This debug message will now be logged')
+* ```
+*/
+function createLogger(options = {}) {
+	const { adapter = new Vuetify0LoggerAdapter({ prefix: options.prefix }), level: initialLevel = "info", enabled: initialEnabled = __LOGGER_ENABLED__ } = options;
+	let currentLevel = initialLevel;
+	let isEnabled = initialEnabled;
+	function value(level$1) {
+		return {
+			trace: 0,
+			debug: 1,
+			info: 2,
+			warn: 3,
+			error: 4,
+			fatal: 5,
+			silent: 6
+		}[level$1] ?? 2;
+	}
+	function can(level$1) {
+		if (!isEnabled) return false;
+		return value(level$1) >= value(currentLevel);
+	}
+	function format(message) {
+		return message;
+	}
+	function debug(message, ...args) {
+		if (can("debug")) adapter.debug(format(message), ...args);
+	}
+	function info(message, ...args) {
+		if (can("info")) adapter.info(format(message), ...args);
+	}
+	function warn(message, ...args) {
+		if (can("warn")) adapter.warn(format(message), ...args);
+	}
+	function error(message, ...args) {
+		if (can("error")) adapter.error(format(message), ...args);
+	}
+	function trace(message, ...args) {
+		if (can("trace")) adapter.trace?.(format(message), ...args);
+	}
+	function fatal(message, ...args) {
+		if (can("fatal")) adapter.fatal?.(format(message), ...args);
+	}
+	function level(newLevel) {
+		currentLevel = newLevel;
+	}
+	function current() {
+		return currentLevel;
+	}
+	function enabled() {
+		return isEnabled;
+	}
+	function enable() {
+		isEnabled = true;
+	}
+	function disable() {
+		isEnabled = false;
+	}
+	return {
+		debug,
+		info,
+		warn,
+		error,
+		trace,
+		fatal,
+		level,
+		current,
+		enabled,
+		enable,
+		disable
+	};
+}
+function createFallbackLogger(namespace = "v0:logger") {
+	function format(message, type) {
+		return `[${namespace} ${type}] ${message}`;
+	}
+	return {
+		debug: (message, ...args) => console.debug(format(message, "debug"), ...args),
+		info: (message, ...args) => console.info(format(message, "info"), ...args),
+		warn: (message, ...args) => console.warn(format(message, "warn"), ...args),
+		error: (message, ...args) => console.error(format(message, "error"), ...args),
+		trace: (message, ...args) => console.trace(format(message, "trace"), ...args),
+		fatal: (message, ...args) => console.error(format(message, "fatal"), ...args),
+		level: () => {},
+		current: () => "info",
+		enabled: () => true,
+		enable: () => {},
+		disable: () => {}
+	};
+}
+/**
+* Creates a new logger context.
+*
+* @param options The options for the logger context.
+* @template E The type of the logger context.
+* @returns A new logger context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @example
+* ```ts
+* import { createLoggerContext } from '@vuetify/v0'
+*
+* export const [useAppLogger, provideAppLogger, appLogger] = createLoggerContext({
+*   namespace: 'app:logger',
+*   level: 'debug',
+* })
+* ```
+*/
+const [createLoggerContext, createLoggerPlugin, useLogger] = createPluginContext("v0:logger", (options) => createLogger(options), {
+	fallback: (ns) => createFallbackLogger(ns),
+	setup: (context, _app, _options) => {
+		if (!/* @__PURE__ */ isUndefined(process.env.NODE_ENV !== "production") && process.env.NODE_ENV !== "production" && IN_BROWSER) window.__v0Logger__ = context;
+	}
+});
+
+//#endregion
+export { createPlugin as a, useLogger as i, createLoggerContext as n, createPluginContext as o, createLoggerPlugin as r, createLogger as t };

package/dist/usePermissions-DQVT_4nD.mjs

@@ -0,0 +1,128 @@
+import { o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
+import { t as createTokens } from "./createTokens-BlhLdHXE.mjs";
+import { t as toArray } from "./toArray-DIeXVX1C.mjs";
+import { t as Vuetify0PermissionAdapter } from "./v0-B40YkIQ-.mjs";
+
+//#region src/composables/usePermissions/index.ts
+/**
+* @module usePermissions
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @remarks
+* Permission management composable with support for RBAC and ABAC patterns.
+*
+* Key features:
+* - Role-Based Access Control (RBAC) support
+* - Attribute-Based Access Control (ABAC) with context
+* - Functional permission conditions
+* - Token-based permission storage
+* - Adapter pattern for custom permission systems
+*
+* Built on useTokens for flexible permission configuration.
+*/
+/**
+* Creates a new permissions instance.
+*
+* @param options The options for the permissions instance.
+* @template Z The type of the permission ticket.
+* @template E The type of the permission context.
+* @returns A new permissions instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @example
+* ```ts
+* import { createPermissions } from '@vuetify/v0'
+*
+* const [usePermissions, providePermissions] = createPermissions({
+*   namespace: 'v0:permissions',
+*   permissions: {
+*     admin: [['read', 'users']],
+*     editor: [['edit', 'posts']],
+*   },
+* })
+* ```
+*/
+function createPermissions(_options = {}) {
+	const { adapter = new Vuetify0PermissionAdapter(), permissions = {}, ...options } = _options;
+	const record = {};
+	for (const role in permissions) {
+		if (!record[role]) record[role] = {};
+		for (const [actions, subjects, condition = true] of permissions[role]) for (const action of toArray(actions)) for (const subject of toArray(subjects)) {
+			if (!record[role][action]) record[role][action] = {};
+			record[role][action][subject] = condition;
+		}
+	}
+	const tokens = createTokens(record, options);
+	function can(id, action, subject, context = {}) {
+		return adapter.can(id, action, subject, context, tokens);
+	}
+	return {
+		...tokens,
+		can
+	};
+}
+/**
+* Creates a new permissions context.
+*
+* @param options The options for the permissions context.
+* @template Z The type of the permission ticket.
+* @template E The type of the permission context.
+* @returns A new permissions context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @example
+* ```ts
+* import { createPermissionsContext } from '@vuetify/v0'
+*
+* export const [usePermissions, providePermissions, context] = createPermissionsContext({
+*   namespace: 'app:permissions',
+*   permissions: {
+*     admin: [['read', 'users'], ['edit', 'users']],
+*     editor: [['edit', 'posts']],
+*   },
+* })
+* ```
+*/
+function createPermissionsFallback() {
+	return {
+		size: 0,
+		can: () => false
+	};
+}
+const [createPermissionsContext, createPermissionsPlugin, usePermissions] = createPluginContext("v0:permissions", (options) => createPermissions(options), { fallback: () => createPermissionsFallback() });
+/**
+* Creates a new permissions plugin.
+*
+* @param options The options for the permissions plugin.
+* @template Z The type of the permission ticket.
+* @template E The type of the permission context.
+* @returns A new permissions plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @example
+* ```ts
+* import { createApp } from 'vue'
+* import { createPermissionsPlugin } from '@vuetify/v0'
+* import App from './App.vue'
+*
+* const app = createApp(App)
+*
+* app.use(
+*   createPermissionsPlugin({
+*     permissions: {
+*       admin: [['read', 'users']],
+*       editor: [['edit', 'posts']],
+*     },
+*   })
+* )
+*
+* app.mount('#app')
+* ```
+*/
+
+//#endregion
+export { usePermissions as i, createPermissionsContext as n, createPermissionsPlugin as r, createPermissions as t };