@pastweb/vue 2.0.0

package/dist/withDefaultProps/withDefaultProps.js

@@ -0,0 +1,84 @@
+import { OPTIONS } from "./constants.js";
+import { shallowReactive, watchEffect } from "vue";
+import { update } from "@pastweb/tools/update";
+//#region src/withDefaultProps/withDefaultProps.ts
+/**
+* Merges Vue props with defaults and returns a reactive normalized object.
+*
+* Defaults are used only when the incoming prop value is `undefined`. Explicit
+* falsy values such as `false`, `0`, and `''` are preserved. The returned object
+* is updated whenever the source props change.
+*
+* Vue coerces absent Boolean props to `false` at runtime, which makes it
+* impossible for this helper to distinguish "not provided" from "explicitly
+* false" when a prop is declared as Boolean. The `booleanChars` option exists
+* for that case: expose the prop as a string union such as `'+' | '-'`, then let
+* this helper normalize those characters back to booleans after defaults are
+* applied. By default, `+` becomes `true` and `-` becomes `false`.
+*
+* A default key named `className` is also exposed as Vue's `class` prop by
+* default.
+*
+* @typeParam T - Resulting props type.
+* @param props - Source Vue props object.
+* @param defaults - Defaults applied when a prop is `undefined`.
+* @param options - Normalization options.
+* @returns Reactive props object containing source props plus defaults.
+*
+* @example
+* ```ts
+* const props = withDefaultProps(
+*   defineProps<{ tone?: string; block?: '+' | '-' }>(),
+*   { tone: 'neutral', block: '-' },
+* );
+* ```
+*
+* @example
+* ```ts
+* // With exclusions
+* const props = withDefaultProps(
+*   defineProps<...>(),
+*   { tone: 'neutral', internalFlag: true, debug: false },
+*   { exclude: ['debug', /^internal/] }
+* );
+* ```
+*/
+function withDefaultProps(props, defaults, options) {
+	const opts = {
+		...OPTIONS,
+		...options
+	};
+	const { booleanChars: [trueChar, falseChar] } = opts;
+	const excludes = Array.isArray(opts.exclude) ? opts.exclude : [opts.exclude];
+	const newProps = shallowReactive({});
+	const shouldExclude = (key) => {
+		if (!opts.exclude) return false;
+		return excludes.some((rule) => {
+			if (typeof rule === "string") return key === rule;
+			if (rule instanceof RegExp) return rule.test(key);
+			return false;
+		});
+	};
+	watchEffect(() => {
+		const merged = { ...props };
+		Object.entries(defaults).forEach(([key, defValue]) => {
+			if (shouldExclude(key)) {
+				if (props[key] !== void 0) merged[opts.className && key === "className" ? "class" : key] = props[key];
+				return;
+			}
+			const value = props[key] !== void 0 ? props[key] : defValue;
+			if (typeof value === "string" && (value === trueChar || value === falseChar)) {
+				merged[key] = value === trueChar ? true : value === falseChar ? false : defValue;
+				return;
+			}
+			const targetKey = opts.className && key === "className" ? "class" : key;
+			merged[targetKey] = value;
+		});
+		update(newProps, merged);
+	});
+	return newProps;
+}
+//#endregion
+export { withDefaultProps };
+
+//# sourceMappingURL=withDefaultProps.js.map

package/dist/withDefaultProps/withDefaultProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDefaultProps.js","names":[],"sources":["../../src/withDefaultProps/withDefaultProps.ts"],"sourcesContent":["import { shallowReactive, watchEffect } from 'vue';\nimport { update } from '@pastweb/tools/update';\nimport { OPTIONS } from './constants';\nimport type { WithDefaultPropsOptions } from './types';\n\n/**\n * Merges Vue props with defaults and returns a reactive normalized object.\n *\n * Defaults are used only when the incoming prop value is `undefined`. Explicit\n * falsy values such as `false`, `0`, and `''` are preserved. The returned object\n * is updated whenever the source props change.\n *\n * Vue coerces absent Boolean props to `false` at runtime, which makes it\n * impossible for this helper to distinguish \"not provided\" from \"explicitly\n * false\" when a prop is declared as Boolean. The `booleanChars` option exists\n * for that case: expose the prop as a string union such as `'+' | '-'`, then let\n * this helper normalize those characters back to booleans after defaults are\n * applied. By default, `+` becomes `true` and `-` becomes `false`.\n *\n * A default key named `className` is also exposed as Vue's `class` prop by\n * default.\n *\n * @typeParam T - Resulting props type.\n * @param props - Source Vue props object.\n * @param defaults - Defaults applied when a prop is `undefined`.\n * @param options - Normalization options.\n * @returns Reactive props object containing source props plus defaults.\n *\n * @example\n * ```ts\n * const props = withDefaultProps(\n *   defineProps<{ tone?: string; block?: '+' | '-' }>(),\n *   { tone: 'neutral', block: '-' },\n * );\n * ```\n *\n * @example\n * ```ts\n * // With exclusions\n * const props = withDefaultProps(\n *   defineProps<...>(),\n *   { tone: 'neutral', internalFlag: true, debug: false },\n *   { exclude: ['debug', /^internal/] }\n * );\n * ```\n */\nexport function withDefaultProps<T>(props: Record<string, any>, defaults: Record<string, any>, options?: WithDefaultPropsOptions): T {\n  const opts = { ...OPTIONS, ...options };\n  const { booleanChars: [trueChar, falseChar] } = opts;\n  const excludes = Array.isArray(opts.exclude) ? opts.exclude : [opts.exclude];\n  const newProps = shallowReactive<Record<string, any>>({});\n\n  const shouldExclude = (key: string): boolean => {\n    if (!opts.exclude) return false;\n\n    return excludes.some((rule) => {\n      if (typeof rule === 'string') {\n        return key === rule;\n      }\n      if (rule instanceof RegExp) {\n        return rule.test(key);\n      }\n      return false;\n    });\n  };\n\n  watchEffect(() => {\n    const merged: Record<string, any> = { ...props };\n\n    Object.entries(defaults).forEach(([key, defValue]) => {\n      if (shouldExclude(key)) {\n        // Still copy the original prop if it exists, but don't apply default\n        if (props[key] !== undefined) {\n          merged[opts.className && key === 'className' ? 'class' : key] = props[key];\n        }\n        return;\n      }\n\n      const value = props[key] !== undefined ? props[key] : defValue;\n\n      // Boolean char normalization\n      if (typeof value === 'string' && (value === trueChar || value === falseChar)) {\n        merged[key] = value === trueChar ? true : value === falseChar ? false : defValue;\n        return;\n      }\n\n      // className special handling\n      const targetKey = opts.className && key === 'className' ? 'class' : key;\n      merged[targetKey] = value;\n    });\n\n    update(newProps, merged);\n  });\n\n  return newProps as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,iBAAoB,OAA4B,UAA+B,SAAsC;CACnI,MAAM,OAAO;EAAE,GAAG;EAAS,GAAG;CAAQ;CACtC,MAAM,EAAE,cAAc,CAAC,UAAU,eAAe;CAChD,MAAM,WAAW,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK,UAAU,CAAC,KAAK,OAAO;CAC3E,MAAM,WAAW,gBAAqC,CAAC,CAAC;CAExD,MAAM,iBAAiB,QAAyB;EAC9C,IAAI,CAAC,KAAK,SAAS,OAAO;EAE1B,OAAO,SAAS,MAAM,SAAS;GAC7B,IAAI,OAAO,SAAS,UAClB,OAAO,QAAQ;GAEjB,IAAI,gBAAgB,QAClB,OAAO,KAAK,KAAK,GAAG;GAEtB,OAAO;EACT,CAAC;CACH;CAEA,kBAAkB;EAChB,MAAM,SAA8B,EAAE,GAAG,MAAM;EAE/C,OAAO,QAAQ,QAAQ,CAAC,CAAC,SAAS,CAAC,KAAK,cAAc;GACpD,IAAI,cAAc,GAAG,GAAG;IAEtB,IAAI,MAAM,SAAS,KAAA,GACjB,OAAO,KAAK,aAAa,QAAQ,cAAc,UAAU,OAAO,MAAM;IAExE;GACF;GAEA,MAAM,QAAQ,MAAM,SAAS,KAAA,IAAY,MAAM,OAAO;GAGtD,IAAI,OAAO,UAAU,aAAa,UAAU,YAAY,UAAU,YAAY;IAC5E,OAAO,OAAO,UAAU,WAAW,OAAO,UAAU,YAAY,QAAQ;IACxE;GACF;GAGA,MAAM,YAAY,KAAK,aAAa,QAAQ,cAAc,UAAU;GACpE,OAAO,aAAa;EACtB,CAAC;EAED,OAAO,UAAU,MAAM;CACzB,CAAC;CAED,OAAO;AACT"}

package/dist/withDefaultPropsHandlers/constants.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/withDefaultPropsHandlers/constants.ts
+const EVENT_HANDLER_PROP_RE = /^on[A-Z]/;
+//#endregion
+exports.EVENT_HANDLER_PROP_RE = EVENT_HANDLER_PROP_RE;
+
+//# sourceMappingURL=constants.cjs.map

package/dist/withDefaultPropsHandlers/constants.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.cjs","names":[],"sources":["../../src/withDefaultPropsHandlers/constants.ts"],"sourcesContent":["export const EVENT_HANDLER_PROP_RE = /^on[A-Z]/;\n"],"mappings":";;AAAA,MAAa,wBAAwB"}

package/dist/withDefaultPropsHandlers/constants.d.cts

@@ -0,0 +1,5 @@
+//#region src/withDefaultPropsHandlers/constants.d.ts
+declare const EVENT_HANDLER_PROP_RE: RegExp;
+//#endregion
+export { EVENT_HANDLER_PROP_RE };
+//# sourceMappingURL=constants.d.cts.map

package/dist/withDefaultPropsHandlers/constants.d.ts

@@ -0,0 +1,5 @@
+//#region src/withDefaultPropsHandlers/constants.d.ts
+declare const EVENT_HANDLER_PROP_RE: RegExp;
+//#endregion
+export { EVENT_HANDLER_PROP_RE };
+//# sourceMappingURL=constants.d.ts.map

package/dist/withDefaultPropsHandlers/constants.js

@@ -0,0 +1,6 @@
+//#region src/withDefaultPropsHandlers/constants.ts
+const EVENT_HANDLER_PROP_RE = /^on[A-Z]/;
+//#endregion
+export { EVENT_HANDLER_PROP_RE };
+
+//# sourceMappingURL=constants.js.map

package/dist/withDefaultPropsHandlers/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../src/withDefaultPropsHandlers/constants.ts"],"sourcesContent":["export const EVENT_HANDLER_PROP_RE = /^on[A-Z]/;\n"],"mappings":";AAAA,MAAa,wBAAwB"}

package/dist/withDefaultPropsHandlers/index.cjs

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

package/dist/withDefaultPropsHandlers/index.d.cts

@@ -0,0 +1,3 @@
+import { WidthDefaultPropsHandlersOptions, WithDefaultPropsHandlersOptions } from "./types.cjs";
+import { withDefaultPropsHandlers } from "./withDefaultPropsHandlers.cjs";
+export { type WidthDefaultPropsHandlersOptions, type WithDefaultPropsHandlersOptions, withDefaultPropsHandlers };

package/dist/withDefaultPropsHandlers/index.d.ts

@@ -0,0 +1,3 @@
+import { WidthDefaultPropsHandlersOptions, WithDefaultPropsHandlersOptions } from "./types.js";
+import { withDefaultPropsHandlers } from "./withDefaultPropsHandlers.js";
+export { type WidthDefaultPropsHandlersOptions, type WithDefaultPropsHandlersOptions, withDefaultPropsHandlers };

package/dist/withDefaultPropsHandlers/index.js

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

package/dist/withDefaultPropsHandlers/types.d.cts

@@ -0,0 +1,12 @@
+import { GetEventHandlersOptions } from "../getEventHandlers/types.cjs";
+import { WithDefaultPropsOptions } from "../withDefaultProps/types.cjs";
+
+//#region src/withDefaultPropsHandlers/types.d.ts
+type WithDefaultPropsHandlersOptions = Omit<WithDefaultPropsOptions, 'exclude'> & Omit<GetEventHandlersOptions, 'exclude'> & {
+  excludeProps?: string | RegExp | (string | RegExp)[];
+  excludeHandlers?: string | RegExp | (string | RegExp)[];
+};
+type WidthDefaultPropsHandlersOptions = WithDefaultPropsHandlersOptions;
+//#endregion
+export { WidthDefaultPropsHandlersOptions, WithDefaultPropsHandlersOptions };
+//# sourceMappingURL=types.d.cts.map

package/dist/withDefaultPropsHandlers/types.d.ts

@@ -0,0 +1,12 @@
+import { GetEventHandlersOptions } from "../getEventHandlers/types.js";
+import { WithDefaultPropsOptions } from "../withDefaultProps/types.js";
+
+//#region src/withDefaultPropsHandlers/types.d.ts
+type WithDefaultPropsHandlersOptions = Omit<WithDefaultPropsOptions, 'exclude'> & Omit<GetEventHandlersOptions, 'exclude'> & {
+  excludeProps?: string | RegExp | (string | RegExp)[];
+  excludeHandlers?: string | RegExp | (string | RegExp)[];
+};
+type WidthDefaultPropsHandlersOptions = WithDefaultPropsHandlersOptions;
+//#endregion
+export { WidthDefaultPropsHandlersOptions, WithDefaultPropsHandlersOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/withDefaultPropsHandlers/withDefaultPropsHandlers.cjs

@@ -0,0 +1,81 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_withDefaultProps_withDefaultProps = require("../withDefaultProps/withDefaultProps.cjs");
+require("../withDefaultProps/index.cjs");
+const require_getEventHandlers_getEventHandlers = require("../getEventHandlers/getEventHandlers.cjs");
+const require_withDefaultPropsHandlers_constants = require("./constants.cjs");
+let vue = require("vue");
+//#region src/withDefaultPropsHandlers/withDefaultPropsHandlers.ts
+/**
+* Combines `withDefaultProps` and `getEventHandlers`.
+*
+* Returns a tuple `[normalizedProps, events]` where:
+* - `normalizedProps` contains regular props merged with defaults (with boolean char normalization and className handling)
+* - `events` contains Vue-style handlers extracted from keys like `onClick`,
+*   ready for Vue's `v-on` binding.
+*
+* Handler props are identified by `on` followed by an uppercase character.
+* This means `onClick` is separated into the returned events object, while
+* ordinary props such as `online` or `once` keep their defaults.
+*
+* @param props - Source Vue props object (usually from `defineProps()`)
+* @param defaults - Default values for both regular props and event handlers (`onClick`, `onChange`, etc.)
+* @param options - Combined options for prop normalization and event filtering
+* @returns `[normalizedProps, events]`
+*
+* @example
+* ```ts
+* const [props, events] = withDefaultPropsHandlers(
+*   defineProps<{ tone?: string; block?: '+' | '-' }>(),
+*   {
+*     tone: 'neutral',
+*     block: '-',
+*     onClick: () => console.log('clicked'),
+*     onChange: (value: any) => console.log('changed', value),
+*     onInternalEvent: () => {},   // can be excluded
+*     debug: false,
+*   },
+*   {
+*     excludeProps: ['debug'],          // exclude from prop defaults
+*     excludeHandlers: /^internal/      // exclude from event handlers
+*   }
+* );
+*
+* // Usage in template:
+* <MyComponent
+*   v-bind="props"
+*   v-on="events"
+* />
+* ```
+*/
+function withDefaultPropsHandlers(props, defaults, options = {}) {
+	const excludeProps = options.excludeProps && Array.isArray(options.excludeProps) ? options.excludeProps : options.excludeProps ? [options.excludeProps] : [];
+	excludeProps.push(require_withDefaultPropsHandlers_constants.EVENT_HANDLER_PROP_RE);
+	const propsOptions = { exclude: excludeProps };
+	if (options.booleanChars) propsOptions.booleanChars = options.booleanChars;
+	if (options.className !== void 0) propsOptions.className = options.className;
+	const propsForDefaults = (0, vue.shallowReactive)({});
+	(0, vue.watchEffect)(() => {
+		const nextProps = Object.fromEntries(Object.entries(props).filter(([key]) => !require_withDefaultPropsHandlers_constants.EVENT_HANDLER_PROP_RE.test(key)));
+		Object.keys(propsForDefaults).forEach((key) => {
+			if (!(key in nextProps)) delete propsForDefaults[key];
+		});
+		Object.assign(propsForDefaults, nextProps);
+	});
+	const newProps = require_withDefaultProps_withDefaultProps.withDefaultProps(propsForDefaults, defaults, propsOptions);
+	const events = (0, vue.shallowReactive)({});
+	(0, vue.watchEffect)(() => {
+		const nextEvents = require_getEventHandlers_getEventHandlers.getEventHandlers({
+			...defaults,
+			...props
+		}, { exclude: options.excludeHandlers });
+		Object.keys(events).forEach((key) => {
+			if (!(key in nextEvents)) delete events[key];
+		});
+		Object.assign(events, nextEvents);
+	});
+	return [newProps, events];
+}
+//#endregion
+exports.withDefaultPropsHandlers = withDefaultPropsHandlers;
+
+//# sourceMappingURL=withDefaultPropsHandlers.cjs.map

package/dist/withDefaultPropsHandlers/withDefaultPropsHandlers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDefaultPropsHandlers.cjs","names":["EVENT_HANDLER_PROP_RE","withDefaultProps","getEventHandlers"],"sources":["../../src/withDefaultPropsHandlers/withDefaultPropsHandlers.ts"],"sourcesContent":["import { shallowReactive, watchEffect } from 'vue';\nimport { withDefaultProps } from '../withDefaultProps';\nimport { getEventHandlers } from '../getEventHandlers';\nimport { EVENT_HANDLER_PROP_RE } from './constants';\nimport type { WithDefaultPropsHandlersOptions } from './types';\n\n/**\n * Combines `withDefaultProps` and `getEventHandlers`.\n *\n * Returns a tuple `[normalizedProps, events]` where:\n * - `normalizedProps` contains regular props merged with defaults (with boolean char normalization and className handling)\n * - `events` contains Vue-style handlers extracted from keys like `onClick`,\n *   ready for Vue's `v-on` binding.\n *\n * Handler props are identified by `on` followed by an uppercase character.\n * This means `onClick` is separated into the returned events object, while\n * ordinary props such as `online` or `once` keep their defaults.\n *\n * @param props - Source Vue props object (usually from `defineProps()`)\n * @param defaults - Default values for both regular props and event handlers (`onClick`, `onChange`, etc.)\n * @param options - Combined options for prop normalization and event filtering\n * @returns `[normalizedProps, events]`\n *\n * @example\n * ```ts\n * const [props, events] = withDefaultPropsHandlers(\n *   defineProps<{ tone?: string; block?: '+' | '-' }>(),\n *   {\n *     tone: 'neutral',\n *     block: '-',\n *     onClick: () => console.log('clicked'),\n *     onChange: (value: any) => console.log('changed', value),\n *     onInternalEvent: () => {},   // can be excluded\n *     debug: false,\n *   },\n *   {\n *     excludeProps: ['debug'],          // exclude from prop defaults\n *     excludeHandlers: /^internal/      // exclude from event handlers\n *   }\n * );\n *\n * // Usage in template:\n * <MyComponent\n *   v-bind=\"props\"\n *   v-on=\"events\"\n * />\n * ```\n */\nexport function withDefaultPropsHandlers<T extends Record<string, any>>(\n  props: Record<string, any>,\n  defaults: Record<string, any>,\n  options: WithDefaultPropsHandlersOptions = {},\n): [T, Record<string, Function>] {\n  const excludeProps = options.excludeProps && Array.isArray(options.excludeProps) ? options.excludeProps : options.excludeProps ? [options.excludeProps] : [];\n  excludeProps.push(EVENT_HANDLER_PROP_RE);\n  const propsOptions: Parameters<typeof withDefaultProps>[2] = {\n    exclude: excludeProps,\n  };\n\n  if (options.booleanChars) {\n    propsOptions.booleanChars = options.booleanChars;\n  }\n\n  if (options.className !== undefined) {\n    propsOptions.className = options.className;\n  }\n\n  const propsForDefaults = shallowReactive<Record<string, any>>({});\n\n  watchEffect(() => {\n    const nextProps = Object.fromEntries(\n      Object.entries(props).filter(([key]) => !EVENT_HANDLER_PROP_RE.test(key)),\n    );\n\n    Object.keys(propsForDefaults).forEach(key => {\n      if (!(key in nextProps)) delete propsForDefaults[key];\n    });\n    Object.assign(propsForDefaults, nextProps);\n  });\n\n  const newProps = withDefaultProps<T>(propsForDefaults, defaults, propsOptions);\n\n  const events = shallowReactive<Record<string, Function>>({});\n\n  watchEffect(() => {\n    const nextEvents = getEventHandlers({ ...defaults, ...props }, {\n      exclude: options.excludeHandlers,\n    });\n\n    Object.keys(events).forEach(key => {\n      if (!(key in nextEvents)) delete events[key];\n    });\n    Object.assign(events, nextEvents);\n  });\n\n  return [newProps as T, events];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,yBACd,OACA,UACA,UAA2C,CAAC,GACb;CAC/B,MAAM,eAAe,QAAQ,gBAAgB,MAAM,QAAQ,QAAQ,YAAY,IAAI,QAAQ,eAAe,QAAQ,eAAe,CAAC,QAAQ,YAAY,IAAI,CAAC;CAC3J,aAAa,KAAKA,2CAAAA,qBAAqB;CACvC,MAAM,eAAuD,EAC3D,SAAS,aACX;CAEA,IAAI,QAAQ,cACV,aAAa,eAAe,QAAQ;CAGtC,IAAI,QAAQ,cAAc,KAAA,GACxB,aAAa,YAAY,QAAQ;CAGnC,MAAM,oBAAA,GAAA,IAAA,gBAAA,CAAwD,CAAC,CAAC;CAEhE,CAAA,GAAA,IAAA,YAAA,OAAkB;EAChB,MAAM,YAAY,OAAO,YACvB,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ,CAAC,SAAS,CAACA,2CAAAA,sBAAsB,KAAK,GAAG,CAAC,CAC1E;EAEA,OAAO,KAAK,gBAAgB,CAAC,CAAC,SAAQ,QAAO;GAC3C,IAAI,EAAE,OAAO,YAAY,OAAO,iBAAiB;EACnD,CAAC;EACD,OAAO,OAAO,kBAAkB,SAAS;CAC3C,CAAC;CAED,MAAM,WAAWC,0CAAAA,iBAAoB,kBAAkB,UAAU,YAAY;CAE7E,MAAM,UAAA,GAAA,IAAA,gBAAA,CAAmD,CAAC,CAAC;CAE3D,CAAA,GAAA,IAAA,YAAA,OAAkB;EAChB,MAAM,aAAaC,0CAAAA,iBAAiB;GAAE,GAAG;GAAU,GAAG;EAAM,GAAG,EAC7D,SAAS,QAAQ,gBACnB,CAAC;EAED,OAAO,KAAK,MAAM,CAAC,CAAC,SAAQ,QAAO;GACjC,IAAI,EAAE,OAAO,aAAa,OAAO,OAAO;EAC1C,CAAC;EACD,OAAO,OAAO,QAAQ,UAAU;CAClC,CAAC;CAED,OAAO,CAAC,UAAe,MAAM;AAC/B"}

package/dist/withDefaultPropsHandlers/withDefaultPropsHandlers.d.cts

@@ -0,0 +1,49 @@
+import { WithDefaultPropsHandlersOptions } from "./types.cjs";
+
+//#region src/withDefaultPropsHandlers/withDefaultPropsHandlers.d.ts
+/**
+ * Combines `withDefaultProps` and `getEventHandlers`.
+ *
+ * Returns a tuple `[normalizedProps, events]` where:
+ * - `normalizedProps` contains regular props merged with defaults (with boolean char normalization and className handling)
+ * - `events` contains Vue-style handlers extracted from keys like `onClick`,
+ *   ready for Vue's `v-on` binding.
+ *
+ * Handler props are identified by `on` followed by an uppercase character.
+ * This means `onClick` is separated into the returned events object, while
+ * ordinary props such as `online` or `once` keep their defaults.
+ *
+ * @param props - Source Vue props object (usually from `defineProps()`)
+ * @param defaults - Default values for both regular props and event handlers (`onClick`, `onChange`, etc.)
+ * @param options - Combined options for prop normalization and event filtering
+ * @returns `[normalizedProps, events]`
+ *
+ * @example
+ * ```ts
+ * const [props, events] = withDefaultPropsHandlers(
+ *   defineProps<{ tone?: string; block?: '+' | '-' }>(),
+ *   {
+ *     tone: 'neutral',
+ *     block: '-',
+ *     onClick: () => console.log('clicked'),
+ *     onChange: (value: any) => console.log('changed', value),
+ *     onInternalEvent: () => {},   // can be excluded
+ *     debug: false,
+ *   },
+ *   {
+ *     excludeProps: ['debug'],          // exclude from prop defaults
+ *     excludeHandlers: /^internal/      // exclude from event handlers
+ *   }
+ * );
+ *
+ * // Usage in template:
+ * <MyComponent
+ *   v-bind="props"
+ *   v-on="events"
+ * />
+ * ```
+ */
+declare function withDefaultPropsHandlers<T extends Record<string, any>>(props: Record<string, any>, defaults: Record<string, any>, options?: WithDefaultPropsHandlersOptions): [T, Record<string, Function>];
+//#endregion
+export { withDefaultPropsHandlers };
+//# sourceMappingURL=withDefaultPropsHandlers.d.cts.map

package/dist/withDefaultPropsHandlers/withDefaultPropsHandlers.d.ts

@@ -0,0 +1,49 @@
+import { WithDefaultPropsHandlersOptions } from "./types.js";
+
+//#region src/withDefaultPropsHandlers/withDefaultPropsHandlers.d.ts
+/**
+ * Combines `withDefaultProps` and `getEventHandlers`.
+ *
+ * Returns a tuple `[normalizedProps, events]` where:
+ * - `normalizedProps` contains regular props merged with defaults (with boolean char normalization and className handling)
+ * - `events` contains Vue-style handlers extracted from keys like `onClick`,
+ *   ready for Vue's `v-on` binding.
+ *
+ * Handler props are identified by `on` followed by an uppercase character.
+ * This means `onClick` is separated into the returned events object, while
+ * ordinary props such as `online` or `once` keep their defaults.
+ *
+ * @param props - Source Vue props object (usually from `defineProps()`)
+ * @param defaults - Default values for both regular props and event handlers (`onClick`, `onChange`, etc.)
+ * @param options - Combined options for prop normalization and event filtering
+ * @returns `[normalizedProps, events]`
+ *
+ * @example
+ * ```ts
+ * const [props, events] = withDefaultPropsHandlers(
+ *   defineProps<{ tone?: string; block?: '+' | '-' }>(),
+ *   {
+ *     tone: 'neutral',
+ *     block: '-',
+ *     onClick: () => console.log('clicked'),
+ *     onChange: (value: any) => console.log('changed', value),
+ *     onInternalEvent: () => {},   // can be excluded
+ *     debug: false,
+ *   },
+ *   {
+ *     excludeProps: ['debug'],          // exclude from prop defaults
+ *     excludeHandlers: /^internal/      // exclude from event handlers
+ *   }
+ * );
+ *
+ * // Usage in template:
+ * <MyComponent
+ *   v-bind="props"
+ *   v-on="events"
+ * />
+ * ```
+ */
+declare function withDefaultPropsHandlers<T extends Record<string, any>>(props: Record<string, any>, defaults: Record<string, any>, options?: WithDefaultPropsHandlersOptions): [T, Record<string, Function>];
+//#endregion
+export { withDefaultPropsHandlers };
+//# sourceMappingURL=withDefaultPropsHandlers.d.ts.map

package/dist/withDefaultPropsHandlers/withDefaultPropsHandlers.js

@@ -0,0 +1,80 @@
+import { withDefaultProps } from "../withDefaultProps/withDefaultProps.js";
+import "../withDefaultProps/index.js";
+import { getEventHandlers } from "../getEventHandlers/getEventHandlers.js";
+import { EVENT_HANDLER_PROP_RE } from "./constants.js";
+import { shallowReactive, watchEffect } from "vue";
+//#region src/withDefaultPropsHandlers/withDefaultPropsHandlers.ts
+/**
+* Combines `withDefaultProps` and `getEventHandlers`.
+*
+* Returns a tuple `[normalizedProps, events]` where:
+* - `normalizedProps` contains regular props merged with defaults (with boolean char normalization and className handling)
+* - `events` contains Vue-style handlers extracted from keys like `onClick`,
+*   ready for Vue's `v-on` binding.
+*
+* Handler props are identified by `on` followed by an uppercase character.
+* This means `onClick` is separated into the returned events object, while
+* ordinary props such as `online` or `once` keep their defaults.
+*
+* @param props - Source Vue props object (usually from `defineProps()`)
+* @param defaults - Default values for both regular props and event handlers (`onClick`, `onChange`, etc.)
+* @param options - Combined options for prop normalization and event filtering
+* @returns `[normalizedProps, events]`
+*
+* @example
+* ```ts
+* const [props, events] = withDefaultPropsHandlers(
+*   defineProps<{ tone?: string; block?: '+' | '-' }>(),
+*   {
+*     tone: 'neutral',
+*     block: '-',
+*     onClick: () => console.log('clicked'),
+*     onChange: (value: any) => console.log('changed', value),
+*     onInternalEvent: () => {},   // can be excluded
+*     debug: false,
+*   },
+*   {
+*     excludeProps: ['debug'],          // exclude from prop defaults
+*     excludeHandlers: /^internal/      // exclude from event handlers
+*   }
+* );
+*
+* // Usage in template:
+* <MyComponent
+*   v-bind="props"
+*   v-on="events"
+* />
+* ```
+*/
+function withDefaultPropsHandlers(props, defaults, options = {}) {
+	const excludeProps = options.excludeProps && Array.isArray(options.excludeProps) ? options.excludeProps : options.excludeProps ? [options.excludeProps] : [];
+	excludeProps.push(EVENT_HANDLER_PROP_RE);
+	const propsOptions = { exclude: excludeProps };
+	if (options.booleanChars) propsOptions.booleanChars = options.booleanChars;
+	if (options.className !== void 0) propsOptions.className = options.className;
+	const propsForDefaults = shallowReactive({});
+	watchEffect(() => {
+		const nextProps = Object.fromEntries(Object.entries(props).filter(([key]) => !EVENT_HANDLER_PROP_RE.test(key)));
+		Object.keys(propsForDefaults).forEach((key) => {
+			if (!(key in nextProps)) delete propsForDefaults[key];
+		});
+		Object.assign(propsForDefaults, nextProps);
+	});
+	const newProps = withDefaultProps(propsForDefaults, defaults, propsOptions);
+	const events = shallowReactive({});
+	watchEffect(() => {
+		const nextEvents = getEventHandlers({
+			...defaults,
+			...props
+		}, { exclude: options.excludeHandlers });
+		Object.keys(events).forEach((key) => {
+			if (!(key in nextEvents)) delete events[key];
+		});
+		Object.assign(events, nextEvents);
+	});
+	return [newProps, events];
+}
+//#endregion
+export { withDefaultPropsHandlers };
+
+//# sourceMappingURL=withDefaultPropsHandlers.js.map

package/dist/withDefaultPropsHandlers/withDefaultPropsHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDefaultPropsHandlers.js","names":[],"sources":["../../src/withDefaultPropsHandlers/withDefaultPropsHandlers.ts"],"sourcesContent":["import { shallowReactive, watchEffect } from 'vue';\nimport { withDefaultProps } from '../withDefaultProps';\nimport { getEventHandlers } from '../getEventHandlers';\nimport { EVENT_HANDLER_PROP_RE } from './constants';\nimport type { WithDefaultPropsHandlersOptions } from './types';\n\n/**\n * Combines `withDefaultProps` and `getEventHandlers`.\n *\n * Returns a tuple `[normalizedProps, events]` where:\n * - `normalizedProps` contains regular props merged with defaults (with boolean char normalization and className handling)\n * - `events` contains Vue-style handlers extracted from keys like `onClick`,\n *   ready for Vue's `v-on` binding.\n *\n * Handler props are identified by `on` followed by an uppercase character.\n * This means `onClick` is separated into the returned events object, while\n * ordinary props such as `online` or `once` keep their defaults.\n *\n * @param props - Source Vue props object (usually from `defineProps()`)\n * @param defaults - Default values for both regular props and event handlers (`onClick`, `onChange`, etc.)\n * @param options - Combined options for prop normalization and event filtering\n * @returns `[normalizedProps, events]`\n *\n * @example\n * ```ts\n * const [props, events] = withDefaultPropsHandlers(\n *   defineProps<{ tone?: string; block?: '+' | '-' }>(),\n *   {\n *     tone: 'neutral',\n *     block: '-',\n *     onClick: () => console.log('clicked'),\n *     onChange: (value: any) => console.log('changed', value),\n *     onInternalEvent: () => {},   // can be excluded\n *     debug: false,\n *   },\n *   {\n *     excludeProps: ['debug'],          // exclude from prop defaults\n *     excludeHandlers: /^internal/      // exclude from event handlers\n *   }\n * );\n *\n * // Usage in template:\n * <MyComponent\n *   v-bind=\"props\"\n *   v-on=\"events\"\n * />\n * ```\n */\nexport function withDefaultPropsHandlers<T extends Record<string, any>>(\n  props: Record<string, any>,\n  defaults: Record<string, any>,\n  options: WithDefaultPropsHandlersOptions = {},\n): [T, Record<string, Function>] {\n  const excludeProps = options.excludeProps && Array.isArray(options.excludeProps) ? options.excludeProps : options.excludeProps ? [options.excludeProps] : [];\n  excludeProps.push(EVENT_HANDLER_PROP_RE);\n  const propsOptions: Parameters<typeof withDefaultProps>[2] = {\n    exclude: excludeProps,\n  };\n\n  if (options.booleanChars) {\n    propsOptions.booleanChars = options.booleanChars;\n  }\n\n  if (options.className !== undefined) {\n    propsOptions.className = options.className;\n  }\n\n  const propsForDefaults = shallowReactive<Record<string, any>>({});\n\n  watchEffect(() => {\n    const nextProps = Object.fromEntries(\n      Object.entries(props).filter(([key]) => !EVENT_HANDLER_PROP_RE.test(key)),\n    );\n\n    Object.keys(propsForDefaults).forEach(key => {\n      if (!(key in nextProps)) delete propsForDefaults[key];\n    });\n    Object.assign(propsForDefaults, nextProps);\n  });\n\n  const newProps = withDefaultProps<T>(propsForDefaults, defaults, propsOptions);\n\n  const events = shallowReactive<Record<string, Function>>({});\n\n  watchEffect(() => {\n    const nextEvents = getEventHandlers({ ...defaults, ...props }, {\n      exclude: options.excludeHandlers,\n    });\n\n    Object.keys(events).forEach(key => {\n      if (!(key in nextEvents)) delete events[key];\n    });\n    Object.assign(events, nextEvents);\n  });\n\n  return [newProps as T, events];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,yBACd,OACA,UACA,UAA2C,CAAC,GACb;CAC/B,MAAM,eAAe,QAAQ,gBAAgB,MAAM,QAAQ,QAAQ,YAAY,IAAI,QAAQ,eAAe,QAAQ,eAAe,CAAC,QAAQ,YAAY,IAAI,CAAC;CAC3J,aAAa,KAAK,qBAAqB;CACvC,MAAM,eAAuD,EAC3D,SAAS,aACX;CAEA,IAAI,QAAQ,cACV,aAAa,eAAe,QAAQ;CAGtC,IAAI,QAAQ,cAAc,KAAA,GACxB,aAAa,YAAY,QAAQ;CAGnC,MAAM,mBAAmB,gBAAqC,CAAC,CAAC;CAEhE,kBAAkB;EAChB,MAAM,YAAY,OAAO,YACvB,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,sBAAsB,KAAK,GAAG,CAAC,CAC1E;EAEA,OAAO,KAAK,gBAAgB,CAAC,CAAC,SAAQ,QAAO;GAC3C,IAAI,EAAE,OAAO,YAAY,OAAO,iBAAiB;EACnD,CAAC;EACD,OAAO,OAAO,kBAAkB,SAAS;CAC3C,CAAC;CAED,MAAM,WAAW,iBAAoB,kBAAkB,UAAU,YAAY;CAE7E,MAAM,SAAS,gBAA0C,CAAC,CAAC;CAE3D,kBAAkB;EAChB,MAAM,aAAa,iBAAiB;GAAE,GAAG;GAAU,GAAG;EAAM,GAAG,EAC7D,SAAS,QAAQ,gBACnB,CAAC;EAED,OAAO,KAAK,MAAM,CAAC,CAAC,SAAQ,QAAO;GACjC,IAAI,EAAE,OAAO,aAAa,OAAO,OAAO;EAC1C,CAAC;EACD,OAAO,OAAO,QAAQ,UAAU;CAClC,CAAC;CAED,OAAO,CAAC,UAAe,MAAM;AAC/B"}