@pastweb/vue 2.0.0

package/dist/createEntry/utils/setupVueEntry/setupVueEntry.d.cts

@@ -0,0 +1,17 @@
+import { VueEntryNormalizedOptions } from "../../types.cjs";
+import { App } from "vue";
+
+//#region src/createEntry/utils/setupVueEntry/setupVueEntry.d.ts
+/**
+ * Applies Vue entry plugins, components, and directives to an app instance.
+ *
+ * Plugin descriptors can pass one or more options to `app.use`. Registered
+ * components and directives are installed globally on the entry app.
+ *
+ * @param app - Vue app instance to configure.
+ * @param options - Normalized Vue entry options.
+ */
+declare function setupVueEntry(app: App<any>, options: VueEntryNormalizedOptions): void;
+//#endregion
+export { setupVueEntry };
+//# sourceMappingURL=setupVueEntry.d.cts.map

package/dist/createEntry/utils/setupVueEntry/setupVueEntry.d.ts

@@ -0,0 +1,17 @@
+import { VueEntryNormalizedOptions } from "../../types.js";
+import { App } from "vue";
+
+//#region src/createEntry/utils/setupVueEntry/setupVueEntry.d.ts
+/**
+ * Applies Vue entry plugins, components, and directives to an app instance.
+ *
+ * Plugin descriptors can pass one or more options to `app.use`. Registered
+ * components and directives are installed globally on the entry app.
+ *
+ * @param app - Vue app instance to configure.
+ * @param options - Normalized Vue entry options.
+ */
+declare function setupVueEntry(app: App<any>, options: VueEntryNormalizedOptions): void;
+//#endregion
+export { setupVueEntry };
+//# sourceMappingURL=setupVueEntry.d.ts.map

package/dist/createEntry/utils/setupVueEntry/setupVueEntry.js

@@ -0,0 +1,30 @@
+//#region src/createEntry/utils/setupVueEntry/setupVueEntry.ts
+/**
+* Applies Vue entry plugins, components, and directives to an app instance.
+*
+* Plugin descriptors can pass one or more options to `app.use`. Registered
+* components and directives are installed globally on the entry app.
+*
+* @param app - Vue app instance to configure.
+* @param options - Normalized Vue entry options.
+*/
+function setupVueEntry(app, options) {
+	const { use, register } = options;
+	use.forEach((_plugin) => {
+		const plugin = _plugin.plugin || _plugin;
+		let options = [];
+		if (_plugin.options) options = Array.isArray(_plugin.options) ? _plugin.options : [_plugin.options];
+		app.use(plugin, ...options);
+	});
+	const { component, directive } = register;
+	Object.entries(component).forEach(([name, component]) => {
+		app.component(name, component);
+	});
+	Object.entries(directive).forEach(([name, directive]) => {
+		app.directive(name, directive);
+	});
+}
+//#endregion
+export { setupVueEntry };
+
+//# sourceMappingURL=setupVueEntry.js.map

package/dist/createEntry/utils/setupVueEntry/setupVueEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupVueEntry.js","names":[],"sources":["../../../../src/createEntry/utils/setupVueEntry/setupVueEntry.ts"],"sourcesContent":["import type { App, Plugin } from 'vue';\nimport type { VueEntryNormalizedOptions, PluginDescriptor } from '../../types';\n\n/**\n * Applies Vue entry plugins, components, and directives to an app instance.\n *\n * Plugin descriptors can pass one or more options to `app.use`. Registered\n * components and directives are installed globally on the entry app.\n *\n * @param app - Vue app instance to configure.\n * @param options - Normalized Vue entry options.\n */\nexport function setupVueEntry(app: App<any>, options: VueEntryNormalizedOptions): void {\n  const { use, register } = options;\n\n  use.forEach((_plugin: Plugin | PluginDescriptor) => {\n    const plugin = (_plugin as PluginDescriptor).plugin || _plugin as Plugin;\n    let options: any[] = [];\n    \n    if ((_plugin as PluginDescriptor).options) {\n      options = Array.isArray((_plugin as PluginDescriptor).options) ?\n        (_plugin as PluginDescriptor).options :\n        [ (_plugin as PluginDescriptor).options ];\n    }\n\n    app.use(plugin, ...options);\n  });\n  \n  const { component, directive } = register;\n\n  Object.entries(component).forEach(([name, component]) => {\n    app.component(name, component);\n  });\n\n  Object.entries(directive).forEach(([name, directive]) => {\n    app.directive(name, directive);\n  });\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,cAAc,KAAe,SAA0C;CACrF,MAAM,EAAE,KAAK,aAAa;CAE1B,IAAI,SAAS,YAAuC;EAClD,MAAM,SAAU,QAA6B,UAAU;EACvD,IAAI,UAAiB,CAAC;EAEtB,IAAK,QAA6B,SAChC,UAAU,MAAM,QAAS,QAA6B,OAAO,IAC1D,QAA6B,UAC9B,CAAG,QAA6B,OAAQ;EAG5C,IAAI,IAAI,QAAQ,GAAG,OAAO;CAC5B,CAAC;CAED,MAAM,EAAE,WAAW,cAAc;CAEjC,OAAO,QAAQ,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,eAAe;EACvD,IAAI,UAAU,MAAM,SAAS;CAC/B,CAAC;CAED,OAAO,QAAQ,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,eAAe;EACvD,IAAI,UAAU,MAAM,SAAS;CAC/B,CAAC;AACH"}

package/dist/createPiniaAsyncStore/createPiniaAsyncStore.cjs

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _pastweb_tools_createAsyncStore = require("@pastweb/tools/createAsyncStore");
+let _pastweb_tools_noop = require("@pastweb/tools/noop");
+let pinia = require("pinia");
+//#region src/createPiniaAsyncStore/createPiniaAsyncStore.ts
+/**
+* Creates an async Pinia store wrapper.
+*
+* The returned object is a tools async store with a Pinia instance attached as
+* `store`. Calling `init()` runs the optional `onInit` callback with that Pinia
+* instance and marks the async store as ready when the callback resolves.
+*
+* @param options - Async Pinia store options.
+* @param options.name - Optional name suffix used for the underlying async store.
+* @param options.onInit - Optional initialization callback that receives the Pinia instance.
+* @returns Async store with a Pinia instance attached.
+*
+* @example
+* ```ts
+* import { createPiniaAsyncStore } from '@pastweb/vue/createPiniaAsyncStore';
+*
+* const piniaStore = createPiniaAsyncStore({
+*   name: 'app',
+*   async onInit(pinia) {
+*     app.use(pinia);
+*   },
+* });
+*
+* await piniaStore.init();
+* ```
+*/
+function createPiniaAsyncStore(options) {
+	const asyncStore = (0, _pastweb_tools_createAsyncStore.createAsyncStore)({
+		...options,
+		name: `PiniaAsyncStore${options.name ? `:${options.name}` : ""}`
+	});
+	const store = (0, pinia.createPinia)();
+	asyncStore.store = store;
+	asyncStore.init = async () => {
+		const { onInit = _pastweb_tools_noop.noop } = asyncStore.options;
+		await onInit(store);
+		asyncStore.setStoreReady();
+	};
+	return asyncStore;
+}
+//#endregion
+exports.createPiniaAsyncStore = createPiniaAsyncStore;
+
+//# sourceMappingURL=createPiniaAsyncStore.cjs.map

package/dist/createPiniaAsyncStore/createPiniaAsyncStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPiniaAsyncStore.cjs","names":["noop"],"sources":["../../src/createPiniaAsyncStore/createPiniaAsyncStore.ts"],"sourcesContent":["import { createAsyncStore } from '@pastweb/tools/createAsyncStore';\nimport { noop } from '@pastweb/tools/noop';\nimport { createPinia } from 'pinia';\nimport type { PiniaAsyncStore, PiniaStoreOptions } from './types';\n\n/**\n * Creates an async Pinia store wrapper.\n *\n * The returned object is a tools async store with a Pinia instance attached as\n * `store`. Calling `init()` runs the optional `onInit` callback with that Pinia\n * instance and marks the async store as ready when the callback resolves.\n *\n * @param options - Async Pinia store options.\n * @param options.name - Optional name suffix used for the underlying async store.\n * @param options.onInit - Optional initialization callback that receives the Pinia instance.\n * @returns Async store with a Pinia instance attached.\n *\n * @example\n * ```ts\n * import { createPiniaAsyncStore } from '@pastweb/vue/createPiniaAsyncStore';\n *\n * const piniaStore = createPiniaAsyncStore({\n *   name: 'app',\n *   async onInit(pinia) {\n *     app.use(pinia);\n *   },\n * });\n *\n * await piniaStore.init();\n * ```\n */\nexport function createPiniaAsyncStore(options: PiniaStoreOptions): PiniaAsyncStore {\n  const asyncStore = createAsyncStore<PiniaAsyncStore>({\n    ...options,\n    name: `PiniaAsyncStore${options.name ? `:${options.name}` : ''}`,\n  });\n\n  const store = createPinia();\n\n  asyncStore.store = store;\n\n  asyncStore.init = async () => {\n    const { onInit = noop } = asyncStore.options as PiniaStoreOptions;\n    await onInit(store);\n    asyncStore.setStoreReady();\n  };\n\n  return asyncStore;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,sBAAsB,SAA6C;CACjF,MAAM,cAAA,GAAA,gCAAA,iBAAA,CAA+C;EACnD,GAAG;EACH,MAAM,kBAAkB,QAAQ,OAAO,IAAI,QAAQ,SAAS;CAC9D,CAAC;CAED,MAAM,SAAA,GAAA,MAAA,YAAA,CAAoB;CAE1B,WAAW,QAAQ;CAEnB,WAAW,OAAO,YAAY;EAC5B,MAAM,EAAE,SAASA,oBAAAA,SAAS,WAAW;EACrC,MAAM,OAAO,KAAK;EAClB,WAAW,cAAc;CAC3B;CAEA,OAAO;AACT"}

package/dist/createPiniaAsyncStore/createPiniaAsyncStore.d.cts

@@ -0,0 +1,33 @@
+import { PiniaAsyncStore, PiniaStoreOptions } from "./types.cjs";
+
+//#region src/createPiniaAsyncStore/createPiniaAsyncStore.d.ts
+/**
+ * Creates an async Pinia store wrapper.
+ *
+ * The returned object is a tools async store with a Pinia instance attached as
+ * `store`. Calling `init()` runs the optional `onInit` callback with that Pinia
+ * instance and marks the async store as ready when the callback resolves.
+ *
+ * @param options - Async Pinia store options.
+ * @param options.name - Optional name suffix used for the underlying async store.
+ * @param options.onInit - Optional initialization callback that receives the Pinia instance.
+ * @returns Async store with a Pinia instance attached.
+ *
+ * @example
+ * ```ts
+ * import { createPiniaAsyncStore } from '@pastweb/vue/createPiniaAsyncStore';
+ *
+ * const piniaStore = createPiniaAsyncStore({
+ *   name: 'app',
+ *   async onInit(pinia) {
+ *     app.use(pinia);
+ *   },
+ * });
+ *
+ * await piniaStore.init();
+ * ```
+ */
+declare function createPiniaAsyncStore(options: PiniaStoreOptions): PiniaAsyncStore;
+//#endregion
+export { createPiniaAsyncStore };
+//# sourceMappingURL=createPiniaAsyncStore.d.cts.map

package/dist/createPiniaAsyncStore/createPiniaAsyncStore.d.ts

@@ -0,0 +1,33 @@
+import { PiniaAsyncStore, PiniaStoreOptions } from "./types.js";
+
+//#region src/createPiniaAsyncStore/createPiniaAsyncStore.d.ts
+/**
+ * Creates an async Pinia store wrapper.
+ *
+ * The returned object is a tools async store with a Pinia instance attached as
+ * `store`. Calling `init()` runs the optional `onInit` callback with that Pinia
+ * instance and marks the async store as ready when the callback resolves.
+ *
+ * @param options - Async Pinia store options.
+ * @param options.name - Optional name suffix used for the underlying async store.
+ * @param options.onInit - Optional initialization callback that receives the Pinia instance.
+ * @returns Async store with a Pinia instance attached.
+ *
+ * @example
+ * ```ts
+ * import { createPiniaAsyncStore } from '@pastweb/vue/createPiniaAsyncStore';
+ *
+ * const piniaStore = createPiniaAsyncStore({
+ *   name: 'app',
+ *   async onInit(pinia) {
+ *     app.use(pinia);
+ *   },
+ * });
+ *
+ * await piniaStore.init();
+ * ```
+ */
+declare function createPiniaAsyncStore(options: PiniaStoreOptions): PiniaAsyncStore;
+//#endregion
+export { createPiniaAsyncStore };
+//# sourceMappingURL=createPiniaAsyncStore.d.ts.map

package/dist/createPiniaAsyncStore/createPiniaAsyncStore.js

@@ -0,0 +1,48 @@
+import { createAsyncStore } from "@pastweb/tools/createAsyncStore";
+import { noop } from "@pastweb/tools/noop";
+import { createPinia } from "pinia";
+//#region src/createPiniaAsyncStore/createPiniaAsyncStore.ts
+/**
+* Creates an async Pinia store wrapper.
+*
+* The returned object is a tools async store with a Pinia instance attached as
+* `store`. Calling `init()` runs the optional `onInit` callback with that Pinia
+* instance and marks the async store as ready when the callback resolves.
+*
+* @param options - Async Pinia store options.
+* @param options.name - Optional name suffix used for the underlying async store.
+* @param options.onInit - Optional initialization callback that receives the Pinia instance.
+* @returns Async store with a Pinia instance attached.
+*
+* @example
+* ```ts
+* import { createPiniaAsyncStore } from '@pastweb/vue/createPiniaAsyncStore';
+*
+* const piniaStore = createPiniaAsyncStore({
+*   name: 'app',
+*   async onInit(pinia) {
+*     app.use(pinia);
+*   },
+* });
+*
+* await piniaStore.init();
+* ```
+*/
+function createPiniaAsyncStore(options) {
+	const asyncStore = createAsyncStore({
+		...options,
+		name: `PiniaAsyncStore${options.name ? `:${options.name}` : ""}`
+	});
+	const store = createPinia();
+	asyncStore.store = store;
+	asyncStore.init = async () => {
+		const { onInit = noop } = asyncStore.options;
+		await onInit(store);
+		asyncStore.setStoreReady();
+	};
+	return asyncStore;
+}
+//#endregion
+export { createPiniaAsyncStore };
+
+//# sourceMappingURL=createPiniaAsyncStore.js.map

package/dist/createPiniaAsyncStore/createPiniaAsyncStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPiniaAsyncStore.js","names":[],"sources":["../../src/createPiniaAsyncStore/createPiniaAsyncStore.ts"],"sourcesContent":["import { createAsyncStore } from '@pastweb/tools/createAsyncStore';\nimport { noop } from '@pastweb/tools/noop';\nimport { createPinia } from 'pinia';\nimport type { PiniaAsyncStore, PiniaStoreOptions } from './types';\n\n/**\n * Creates an async Pinia store wrapper.\n *\n * The returned object is a tools async store with a Pinia instance attached as\n * `store`. Calling `init()` runs the optional `onInit` callback with that Pinia\n * instance and marks the async store as ready when the callback resolves.\n *\n * @param options - Async Pinia store options.\n * @param options.name - Optional name suffix used for the underlying async store.\n * @param options.onInit - Optional initialization callback that receives the Pinia instance.\n * @returns Async store with a Pinia instance attached.\n *\n * @example\n * ```ts\n * import { createPiniaAsyncStore } from '@pastweb/vue/createPiniaAsyncStore';\n *\n * const piniaStore = createPiniaAsyncStore({\n *   name: 'app',\n *   async onInit(pinia) {\n *     app.use(pinia);\n *   },\n * });\n *\n * await piniaStore.init();\n * ```\n */\nexport function createPiniaAsyncStore(options: PiniaStoreOptions): PiniaAsyncStore {\n  const asyncStore = createAsyncStore<PiniaAsyncStore>({\n    ...options,\n    name: `PiniaAsyncStore${options.name ? `:${options.name}` : ''}`,\n  });\n\n  const store = createPinia();\n\n  asyncStore.store = store;\n\n  asyncStore.init = async () => {\n    const { onInit = noop } = asyncStore.options as PiniaStoreOptions;\n    await onInit(store);\n    asyncStore.setStoreReady();\n  };\n\n  return asyncStore;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,sBAAsB,SAA6C;CACjF,MAAM,aAAa,iBAAkC;EACnD,GAAG;EACH,MAAM,kBAAkB,QAAQ,OAAO,IAAI,QAAQ,SAAS;CAC9D,CAAC;CAED,MAAM,QAAQ,YAAY;CAE1B,WAAW,QAAQ;CAEnB,WAAW,OAAO,YAAY;EAC5B,MAAM,EAAE,SAAS,SAAS,WAAW;EACrC,MAAM,OAAO,KAAK;EAClB,WAAW,cAAc;CAC3B;CAEA,OAAO;AACT"}

package/dist/createPiniaAsyncStore/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_createPiniaAsyncStore_createPiniaAsyncStore = require("./createPiniaAsyncStore.cjs");
+exports.createPiniaAsyncStore = require_createPiniaAsyncStore_createPiniaAsyncStore.createPiniaAsyncStore;

package/dist/createPiniaAsyncStore/index.d.cts

@@ -0,0 +1,3 @@
+import { PiniaAsyncStore, PiniaStoreOptions } from "./types.cjs";
+import { createPiniaAsyncStore } from "./createPiniaAsyncStore.cjs";
+export { type PiniaAsyncStore, type PiniaStoreOptions, createPiniaAsyncStore };

package/dist/createPiniaAsyncStore/index.d.ts

@@ -0,0 +1,3 @@
+import { PiniaAsyncStore, PiniaStoreOptions } from "./types.js";
+import { createPiniaAsyncStore } from "./createPiniaAsyncStore.js";
+export { type PiniaAsyncStore, type PiniaStoreOptions, createPiniaAsyncStore };

package/dist/createPiniaAsyncStore/index.js

@@ -0,0 +1,2 @@
+import { createPiniaAsyncStore } from "./createPiniaAsyncStore.js";
+export { createPiniaAsyncStore };

package/dist/createPiniaAsyncStore/types.d.cts

@@ -0,0 +1,22 @@
+import { AsyncStore, AsyncStoreOptions } from "@pastweb/tools";
+import { Pinia } from "pinia";
+
+//#region src/createPiniaAsyncStore/types.d.ts
+/**
+ * Options accepted by {@link createPiniaAsyncStore}.
+ */
+interface PiniaStoreOptions {
+  /** Optional name suffix appended to the underlying async store name. */
+  name?: string;
+  /** Callback executed by `init` with the created Pinia instance. */
+  onInit?: (pinia: Pinia) => Promise<void> | void;
+}
+/**
+ * Tools async store enhanced with a Pinia instance.
+ */
+type PiniaAsyncStore = AsyncStore<AsyncStoreOptions & PiniaStoreOptions> & {
+  /** Pinia instance created by `createPinia`. */store: Pinia;
+};
+//#endregion
+export { PiniaAsyncStore, PiniaStoreOptions };
+//# sourceMappingURL=types.d.cts.map

package/dist/createPiniaAsyncStore/types.d.ts

@@ -0,0 +1,22 @@
+import { Pinia } from "pinia";
+import { AsyncStore, AsyncStoreOptions } from "@pastweb/tools";
+
+//#region src/createPiniaAsyncStore/types.d.ts
+/**
+ * Options accepted by {@link createPiniaAsyncStore}.
+ */
+interface PiniaStoreOptions {
+  /** Optional name suffix appended to the underlying async store name. */
+  name?: string;
+  /** Callback executed by `init` with the created Pinia instance. */
+  onInit?: (pinia: Pinia) => Promise<void> | void;
+}
+/**
+ * Tools async store enhanced with a Pinia instance.
+ */
+type PiniaAsyncStore = AsyncStore<AsyncStoreOptions & PiniaStoreOptions> & {
+  /** Pinia instance created by `createPinia`. */store: Pinia;
+};
+//#endregion
+export { PiniaAsyncStore, PiniaStoreOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/getContext/getContext.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let vue = require("vue");
+//#region src/getContext/getContext.ts
+/**
+* Reads a value from the active Vue dependency-injection context.
+*
+* Use this helper instead of importing `inject` directly inside package
+* composables so context access stays consistent across the Vue integration.
+* It must be called during component setup, or from a composable that runs
+* during setup.
+*
+* @typeParam T - Expected value type for the provided context value.
+* @param key - String key used when the value was provided with {@link setContext}.
+* @returns The injected value cast to `T`, or `undefined` when no provider exists.
+*
+* @example
+* ```ts
+* import { getContext } from '@pastweb/vue';
+*
+* const session = getContext<{ userId: string }>('session');
+* ```
+*/
+function getContext(key) {
+	return (0, vue.inject)(key, void 0);
+}
+//#endregion
+exports.getContext = getContext;
+
+//# sourceMappingURL=getContext.cjs.map

package/dist/getContext/getContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getContext.cjs","names":[],"sources":["../../src/getContext/getContext.ts"],"sourcesContent":["import { inject } from 'vue';\n\n/**\n * Reads a value from the active Vue dependency-injection context.\n *\n * Use this helper instead of importing `inject` directly inside package\n * composables so context access stays consistent across the Vue integration.\n * It must be called during component setup, or from a composable that runs\n * during setup.\n *\n * @typeParam T - Expected value type for the provided context value.\n * @param key - String key used when the value was provided with {@link setContext}.\n * @returns The injected value cast to `T`, or `undefined` when no provider exists.\n *\n * @example\n * ```ts\n * import { getContext } from '@pastweb/vue';\n *\n * const session = getContext<{ userId: string }>('session');\n * ```\n */\nexport function getContext<T = any>(key: string): T {\n  return inject(key, undefined) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,WAAoB,KAAgB;CAClD,QAAA,GAAA,IAAA,OAAA,CAAc,KAAK,KAAA,CAAS;AAC9B"}

package/dist/getContext/getContext.d.cts

@@ -0,0 +1,24 @@
+//#region src/getContext/getContext.d.ts
+/**
+ * Reads a value from the active Vue dependency-injection context.
+ *
+ * Use this helper instead of importing `inject` directly inside package
+ * composables so context access stays consistent across the Vue integration.
+ * It must be called during component setup, or from a composable that runs
+ * during setup.
+ *
+ * @typeParam T - Expected value type for the provided context value.
+ * @param key - String key used when the value was provided with {@link setContext}.
+ * @returns The injected value cast to `T`, or `undefined` when no provider exists.
+ *
+ * @example
+ * ```ts
+ * import { getContext } from '@pastweb/vue';
+ *
+ * const session = getContext<{ userId: string }>('session');
+ * ```
+ */
+declare function getContext<T = any>(key: string): T;
+//#endregion
+export { getContext };
+//# sourceMappingURL=getContext.d.cts.map

package/dist/getContext/getContext.d.ts

@@ -0,0 +1,24 @@
+//#region src/getContext/getContext.d.ts
+/**
+ * Reads a value from the active Vue dependency-injection context.
+ *
+ * Use this helper instead of importing `inject` directly inside package
+ * composables so context access stays consistent across the Vue integration.
+ * It must be called during component setup, or from a composable that runs
+ * during setup.
+ *
+ * @typeParam T - Expected value type for the provided context value.
+ * @param key - String key used when the value was provided with {@link setContext}.
+ * @returns The injected value cast to `T`, or `undefined` when no provider exists.
+ *
+ * @example
+ * ```ts
+ * import { getContext } from '@pastweb/vue';
+ *
+ * const session = getContext<{ userId: string }>('session');
+ * ```
+ */
+declare function getContext<T = any>(key: string): T;
+//#endregion
+export { getContext };
+//# sourceMappingURL=getContext.d.ts.map

package/dist/getContext/getContext.js

@@ -0,0 +1,28 @@
+import { inject } from "vue";
+//#region src/getContext/getContext.ts
+/**
+* Reads a value from the active Vue dependency-injection context.
+*
+* Use this helper instead of importing `inject` directly inside package
+* composables so context access stays consistent across the Vue integration.
+* It must be called during component setup, or from a composable that runs
+* during setup.
+*
+* @typeParam T - Expected value type for the provided context value.
+* @param key - String key used when the value was provided with {@link setContext}.
+* @returns The injected value cast to `T`, or `undefined` when no provider exists.
+*
+* @example
+* ```ts
+* import { getContext } from '@pastweb/vue';
+*
+* const session = getContext<{ userId: string }>('session');
+* ```
+*/
+function getContext(key) {
+	return inject(key, void 0);
+}
+//#endregion
+export { getContext };
+
+//# sourceMappingURL=getContext.js.map

package/dist/getContext/getContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getContext.js","names":[],"sources":["../../src/getContext/getContext.ts"],"sourcesContent":["import { inject } from 'vue';\n\n/**\n * Reads a value from the active Vue dependency-injection context.\n *\n * Use this helper instead of importing `inject` directly inside package\n * composables so context access stays consistent across the Vue integration.\n * It must be called during component setup, or from a composable that runs\n * during setup.\n *\n * @typeParam T - Expected value type for the provided context value.\n * @param key - String key used when the value was provided with {@link setContext}.\n * @returns The injected value cast to `T`, or `undefined` when no provider exists.\n *\n * @example\n * ```ts\n * import { getContext } from '@pastweb/vue';\n *\n * const session = getContext<{ userId: string }>('session');\n * ```\n */\nexport function getContext<T = any>(key: string): T {\n  return inject(key, undefined) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,WAAoB,KAAgB;CAClD,OAAO,OAAO,KAAK,KAAA,CAAS;AAC9B"}

package/dist/getContext/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_getContext_getContext = require("./getContext.cjs");
+exports.getContext = require_getContext_getContext.getContext;

package/dist/getContext/index.d.cts

@@ -0,0 +1,2 @@
+import { getContext } from "./getContext.cjs";
+export { getContext };

package/dist/getContext/index.d.ts

@@ -0,0 +1,2 @@
+import { getContext } from "./getContext.js";
+export { getContext };

package/dist/getContext/index.js

@@ -0,0 +1,2 @@
+import { getContext } from "./getContext.js";
+export { getContext };

package/dist/getEventHandlers/getEventHandlers.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/getEventHandlers/getEventHandlers.ts
+const EVENT_HANDLER_PROP_RE = /^on[A-Z]/;
+/**
+* Converts Vue-style event handler properties from a props object into a plain
+* object suitable for Vue's `v-on` directive binding.
+*
+* Handler props must start with `on` followed by an uppercase character, such
+* as `onClick`, `onChange`, or `onUpdateModelValue`. This keeps ordinary props
+* such as `online` or `once` from being treated as events. The helper strips
+* the `on` prefix and converts camelCase to kebab-case (for example,
+* `onMyCustomEvent` becomes `my-custom-event`).
+*
+* @param props - The object containing component props and event handlers
+*                (e.g. `{ title: string, onClick: Function, onChange: Function }`)
+* @param options - Configuration options
+* @param options.exclude - Event names (without "on" prefix) to exclude.
+*                          Can be a string, RegExp, or array of both.
+*                          Exclusion is matched against the kebab-cased event name.
+*
+* @returns An object with event names as keys and handler functions as values,
+*          ready to be used with `v-on="events"`
+*
+* @example
+* ```ts
+* const props = {
+*   title: "Hello",
+*   disabled: false,
+*   onClick: () => console.log('clicked'),
+*   onChange: (value: string) => console.log(value),
+*   onMyCustomEvent: (payload: any) => {},
+*   onUpdateModelValue: (val: any) => {},
+* }
+*
+* const events = getEventHandlers(props, {
+*   exclude: ['update:model-value', /^my-/]
+* })
+*
+* // Result: { click: fn, change: fn }
+* ```
+*/
+function getEventHandlers(props, options = {}) {
+	const events = {};
+	const { exclude } = options;
+	const shouldExclude = (eventName) => {
+		if (!exclude) return false;
+		return (Array.isArray(exclude) ? exclude : [exclude]).some((rule) => {
+			if (typeof rule === "string") return eventName === rule;
+			if (rule instanceof RegExp) return rule.test(eventName);
+			return false;
+		});
+	};
+	for (const [key, value] of Object.entries(props)) {
+		if (!EVENT_HANDLER_PROP_RE.test(key) || typeof value !== "function") continue;
+		let eventName = key.slice(2);
+		eventName = eventName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+		if (shouldExclude(eventName)) continue;
+		events[eventName] = value;
+	}
+	return events;
+}
+//#endregion
+exports.getEventHandlers = getEventHandlers;
+
+//# sourceMappingURL=getEventHandlers.cjs.map

package/dist/getEventHandlers/getEventHandlers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEventHandlers.cjs","names":[],"sources":["../../src/getEventHandlers/getEventHandlers.ts"],"sourcesContent":["import type { GetEventHandlersOptions } from './types'\n\nconst EVENT_HANDLER_PROP_RE = /^on[A-Z]/\n\n/**\n * Converts Vue-style event handler properties from a props object into a plain\n * object suitable for Vue's `v-on` directive binding.\n *\n * Handler props must start with `on` followed by an uppercase character, such\n * as `onClick`, `onChange`, or `onUpdateModelValue`. This keeps ordinary props\n * such as `online` or `once` from being treated as events. The helper strips\n * the `on` prefix and converts camelCase to kebab-case (for example,\n * `onMyCustomEvent` becomes `my-custom-event`).\n *\n * @param props - The object containing component props and event handlers\n *                (e.g. `{ title: string, onClick: Function, onChange: Function }`)\n * @param options - Configuration options\n * @param options.exclude - Event names (without \"on\" prefix) to exclude.\n *                          Can be a string, RegExp, or array of both.\n *                          Exclusion is matched against the kebab-cased event name.\n *\n * @returns An object with event names as keys and handler functions as values,\n *          ready to be used with `v-on=\"events\"`\n *\n * @example\n * ```ts\n * const props = {\n *   title: \"Hello\",\n *   disabled: false,\n *   onClick: () => console.log('clicked'),\n *   onChange: (value: string) => console.log(value),\n *   onMyCustomEvent: (payload: any) => {},\n *   onUpdateModelValue: (val: any) => {},\n * }\n *\n * const events = getEventHandlers(props, {\n *   exclude: ['update:model-value', /^my-/]\n * })\n *\n * // Result: { click: fn, change: fn }\n * ```\n */\nexport function getEventHandlers(props: Record<string, any>, options: GetEventHandlersOptions = {}): Record<string, Function> {\n  const events: Record<string, Function> = {}\n  const { exclude } = options\n\n  const shouldExclude = (eventName: string): boolean => {\n    if (!exclude) return false\n\n    const excludes = Array.isArray(exclude) ? exclude : [exclude]\n\n    return excludes.some((rule) => {\n      if (typeof rule === 'string') {\n        return eventName === rule\n      }\n      if (rule instanceof RegExp) {\n        return rule.test(eventName)\n      }\n      return false\n    })\n  }\n\n  for (const [key, value] of Object.entries(props)) {\n    if (!EVENT_HANDLER_PROP_RE.test(key) || typeof value !== 'function') {\n      continue\n    }\n\n    // Remove \"on\" prefix\n    let eventName = key.slice(2)\n\n    // Convert to kebab-case (e.g., MyCustomEvent → my-custom-event)\n    eventName = eventName\n      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')\n      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n      .toLowerCase()\n\n    // Check exclusion (applied to the name without \"on\")\n    if (shouldExclude(eventName)) {\n      continue\n    }\n\n    events[eventName] = value\n  }\n\n  return events\n}\n"],"mappings":";;AAEA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwC9B,SAAgB,iBAAiB,OAA4B,UAAmC,CAAC,GAA6B;CAC5H,MAAM,SAAmC,CAAC;CAC1C,MAAM,EAAE,YAAY;CAEpB,MAAM,iBAAiB,cAA+B;EACpD,IAAI,CAAC,SAAS,OAAO;EAIrB,QAFiB,MAAM,QAAQ,OAAO,IAAI,UAAU,CAAC,OAAO,EAAA,CAE5C,MAAM,SAAS;GAC7B,IAAI,OAAO,SAAS,UAClB,OAAO,cAAc;GAEvB,IAAI,gBAAgB,QAClB,OAAO,KAAK,KAAK,SAAS;GAE5B,OAAO;EACT,CAAC;CACH;CAEA,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG;EAChD,IAAI,CAAC,sBAAsB,KAAK,GAAG,KAAK,OAAO,UAAU,YACvD;EAIF,IAAI,YAAY,IAAI,MAAM,CAAC;EAG3B,YAAY,UACT,QAAQ,yBAAyB,OAAO,CAAC,CACzC,QAAQ,sBAAsB,OAAO,CAAC,CACtC,YAAY;EAGf,IAAI,cAAc,SAAS,GACzB;EAGF,OAAO,aAAa;CACtB;CAEA,OAAO;AACT"}

package/dist/getEventHandlers/getEventHandlers.d.cts

@@ -0,0 +1,45 @@
+import { GetEventHandlersOptions } from "./types.cjs";
+
+//#region src/getEventHandlers/getEventHandlers.d.ts
+/**
+ * Converts Vue-style event handler properties from a props object into a plain
+ * object suitable for Vue's `v-on` directive binding.
+ *
+ * Handler props must start with `on` followed by an uppercase character, such
+ * as `onClick`, `onChange`, or `onUpdateModelValue`. This keeps ordinary props
+ * such as `online` or `once` from being treated as events. The helper strips
+ * the `on` prefix and converts camelCase to kebab-case (for example,
+ * `onMyCustomEvent` becomes `my-custom-event`).
+ *
+ * @param props - The object containing component props and event handlers
+ *                (e.g. `{ title: string, onClick: Function, onChange: Function }`)
+ * @param options - Configuration options
+ * @param options.exclude - Event names (without "on" prefix) to exclude.
+ *                          Can be a string, RegExp, or array of both.
+ *                          Exclusion is matched against the kebab-cased event name.
+ *
+ * @returns An object with event names as keys and handler functions as values,
+ *          ready to be used with `v-on="events"`
+ *
+ * @example
+ * ```ts
+ * const props = {
+ *   title: "Hello",
+ *   disabled: false,
+ *   onClick: () => console.log('clicked'),
+ *   onChange: (value: string) => console.log(value),
+ *   onMyCustomEvent: (payload: any) => {},
+ *   onUpdateModelValue: (val: any) => {},
+ * }
+ *
+ * const events = getEventHandlers(props, {
+ *   exclude: ['update:model-value', /^my-/]
+ * })
+ *
+ * // Result: { click: fn, change: fn }
+ * ```
+ */
+declare function getEventHandlers(props: Record<string, any>, options?: GetEventHandlersOptions): Record<string, Function>;
+//#endregion
+export { getEventHandlers };
+//# sourceMappingURL=getEventHandlers.d.cts.map

package/dist/getEventHandlers/getEventHandlers.d.ts

@@ -0,0 +1,45 @@
+import { GetEventHandlersOptions } from "./types.js";
+
+//#region src/getEventHandlers/getEventHandlers.d.ts
+/**
+ * Converts Vue-style event handler properties from a props object into a plain
+ * object suitable for Vue's `v-on` directive binding.
+ *
+ * Handler props must start with `on` followed by an uppercase character, such
+ * as `onClick`, `onChange`, or `onUpdateModelValue`. This keeps ordinary props
+ * such as `online` or `once` from being treated as events. The helper strips
+ * the `on` prefix and converts camelCase to kebab-case (for example,
+ * `onMyCustomEvent` becomes `my-custom-event`).
+ *
+ * @param props - The object containing component props and event handlers
+ *                (e.g. `{ title: string, onClick: Function, onChange: Function }`)
+ * @param options - Configuration options
+ * @param options.exclude - Event names (without "on" prefix) to exclude.
+ *                          Can be a string, RegExp, or array of both.
+ *                          Exclusion is matched against the kebab-cased event name.
+ *
+ * @returns An object with event names as keys and handler functions as values,
+ *          ready to be used with `v-on="events"`
+ *
+ * @example
+ * ```ts
+ * const props = {
+ *   title: "Hello",
+ *   disabled: false,
+ *   onClick: () => console.log('clicked'),
+ *   onChange: (value: string) => console.log(value),
+ *   onMyCustomEvent: (payload: any) => {},
+ *   onUpdateModelValue: (val: any) => {},
+ * }
+ *
+ * const events = getEventHandlers(props, {
+ *   exclude: ['update:model-value', /^my-/]
+ * })
+ *
+ * // Result: { click: fn, change: fn }
+ * ```
+ */
+declare function getEventHandlers(props: Record<string, any>, options?: GetEventHandlersOptions): Record<string, Function>;
+//#endregion
+export { getEventHandlers };
+//# sourceMappingURL=getEventHandlers.d.ts.map