@pastweb/vue 2.0.0

package/dist/useMediator/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/useMediator/utils.ts"],"sourcesContent":["import { update } from '@pastweb/tools/update';\n\n/**\n * Synchronizes a mutable record with a source object.\n *\n * Keys missing from the source are removed from the target, then remaining\n * values are merged with the shared tools `update` helper.\n *\n * @param target - Mutable record to update in place.\n * @param source - Source values that should remain on the target.\n */\nexport function syncRecord(target: Record<string, any>, source: Record<string, any>): void {\n  Object.keys(target).forEach(key => {\n    if (!(key in source)) delete target[key];\n  });\n\n  update(target, source);\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,WAAW,QAA6B,QAAmC;CACzF,OAAO,KAAK,MAAM,CAAC,CAAC,SAAQ,QAAO;EACjC,IAAI,EAAE,OAAO,SAAS,OAAO,OAAO;CACtC,CAAC;CAED,OAAO,QAAQ,MAAM;AACvB"}

package/dist/useMounted/index.cjs

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

package/dist/useMounted/index.d.cts

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

package/dist/useMounted/index.d.ts

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

package/dist/useMounted/index.js

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

package/dist/useMounted/useMounted.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let vue = require("vue");
+//#region src/useMounted/useMounted.ts
+/**
+* Registers a callback with Vue's `onMounted` lifecycle hook.
+*
+* Use it for work that requires the component to be mounted, such as reading
+* DOM refs, installing browser-only listeners, or starting client-side effects.
+* Async callbacks are accepted, but Vue does not use the returned promise as a
+* cleanup function.
+*
+* @param fn - Callback invoked once after the component mounts.
+*
+* @example
+* ```ts
+* import { useMounted } from '@pastweb/vue';
+*
+* useMounted(() => {
+*   inputRef.value?.focus();
+* });
+* ```
+*/
+function useMounted(fn) {
+	(0, vue.onMounted)(fn);
+}
+//#endregion
+exports.useMounted = useMounted;
+
+//# sourceMappingURL=useMounted.cjs.map

package/dist/useMounted/useMounted.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMounted.cjs","names":[],"sources":["../../src/useMounted/useMounted.ts"],"sourcesContent":["import { onMounted } from 'vue';\n\n/**\n * Registers a callback with Vue's `onMounted` lifecycle hook.\n *\n * Use it for work that requires the component to be mounted, such as reading\n * DOM refs, installing browser-only listeners, or starting client-side effects.\n * Async callbacks are accepted, but Vue does not use the returned promise as a\n * cleanup function.\n *\n * @param fn - Callback invoked once after the component mounts.\n *\n * @example\n * ```ts\n * import { useMounted } from '@pastweb/vue';\n *\n * useMounted(() => {\n *   inputRef.value?.focus();\n * });\n * ```\n */\nexport function useMounted(fn: () => void | Promise<void>): void {\n  onMounted(fn);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,WAAW,IAAsC;CAC/D,CAAA,GAAA,IAAA,UAAA,CAAU,EAAE;AACd"}

package/dist/useMounted/useMounted.d.cts

@@ -0,0 +1,24 @@
+//#region src/useMounted/useMounted.d.ts
+/**
+ * Registers a callback with Vue's `onMounted` lifecycle hook.
+ *
+ * Use it for work that requires the component to be mounted, such as reading
+ * DOM refs, installing browser-only listeners, or starting client-side effects.
+ * Async callbacks are accepted, but Vue does not use the returned promise as a
+ * cleanup function.
+ *
+ * @param fn - Callback invoked once after the component mounts.
+ *
+ * @example
+ * ```ts
+ * import { useMounted } from '@pastweb/vue';
+ *
+ * useMounted(() => {
+ *   inputRef.value?.focus();
+ * });
+ * ```
+ */
+declare function useMounted(fn: () => void | Promise<void>): void;
+//#endregion
+export { useMounted };
+//# sourceMappingURL=useMounted.d.cts.map

package/dist/useMounted/useMounted.d.ts

@@ -0,0 +1,24 @@
+//#region src/useMounted/useMounted.d.ts
+/**
+ * Registers a callback with Vue's `onMounted` lifecycle hook.
+ *
+ * Use it for work that requires the component to be mounted, such as reading
+ * DOM refs, installing browser-only listeners, or starting client-side effects.
+ * Async callbacks are accepted, but Vue does not use the returned promise as a
+ * cleanup function.
+ *
+ * @param fn - Callback invoked once after the component mounts.
+ *
+ * @example
+ * ```ts
+ * import { useMounted } from '@pastweb/vue';
+ *
+ * useMounted(() => {
+ *   inputRef.value?.focus();
+ * });
+ * ```
+ */
+declare function useMounted(fn: () => void | Promise<void>): void;
+//#endregion
+export { useMounted };
+//# sourceMappingURL=useMounted.d.ts.map

package/dist/useMounted/useMounted.js

@@ -0,0 +1,28 @@
+import { onMounted } from "vue";
+//#region src/useMounted/useMounted.ts
+/**
+* Registers a callback with Vue's `onMounted` lifecycle hook.
+*
+* Use it for work that requires the component to be mounted, such as reading
+* DOM refs, installing browser-only listeners, or starting client-side effects.
+* Async callbacks are accepted, but Vue does not use the returned promise as a
+* cleanup function.
+*
+* @param fn - Callback invoked once after the component mounts.
+*
+* @example
+* ```ts
+* import { useMounted } from '@pastweb/vue';
+*
+* useMounted(() => {
+*   inputRef.value?.focus();
+* });
+* ```
+*/
+function useMounted(fn) {
+	onMounted(fn);
+}
+//#endregion
+export { useMounted };
+
+//# sourceMappingURL=useMounted.js.map

package/dist/useMounted/useMounted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMounted.js","names":[],"sources":["../../src/useMounted/useMounted.ts"],"sourcesContent":["import { onMounted } from 'vue';\n\n/**\n * Registers a callback with Vue's `onMounted` lifecycle hook.\n *\n * Use it for work that requires the component to be mounted, such as reading\n * DOM refs, installing browser-only listeners, or starting client-side effects.\n * Async callbacks are accepted, but Vue does not use the returned promise as a\n * cleanup function.\n *\n * @param fn - Callback invoked once after the component mounts.\n *\n * @example\n * ```ts\n * import { useMounted } from '@pastweb/vue';\n *\n * useMounted(() => {\n *   inputRef.value?.focus();\n * });\n * ```\n */\nexport function useMounted(fn: () => void | Promise<void>): void {\n  onMounted(fn);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,WAAW,IAAsC;CAC/D,UAAU,EAAE;AACd"}

package/dist/useRef/index.cjs

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

package/dist/useRef/index.d.cts

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

package/dist/useRef/index.d.ts

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

package/dist/useRef/index.js

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

package/dist/useRef/useRef.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let vue = require("vue");
+//#region src/useRef/useRef.ts
+/**
+* Creates a Vue `shallowRef` with Pastweb's cross-framework ref naming.
+*
+* The returned value is a normal Vue ref, so consumers read and write through
+* `.value`. Because it is shallow, assigning a new value is reactive, while
+* nested object mutation is not deeply tracked by this helper.
+*
+* @param value - Optional initial ref value.
+* @returns Vue shallow ref containing the initial value.
+*
+* @example
+* ```ts
+* import { useRef } from '@pastweb/vue';
+*
+* const element = useRef<HTMLElement | null>(null);
+* element.value?.focus();
+* ```
+*/
+function useRef(value) {
+	return (0, vue.shallowRef)(value);
+}
+//#endregion
+exports.useRef = useRef;
+
+//# sourceMappingURL=useRef.cjs.map

package/dist/useRef/useRef.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRef.cjs","names":[],"sources":["../../src/useRef/useRef.ts"],"sourcesContent":["import { shallowRef, type Ref } from 'vue';\n\n/**\n * Creates a Vue `shallowRef` with Pastweb's cross-framework ref naming.\n *\n * The returned value is a normal Vue ref, so consumers read and write through\n * `.value`. Because it is shallow, assigning a new value is reactive, while\n * nested object mutation is not deeply tracked by this helper.\n *\n * @param value - Optional initial ref value.\n * @returns Vue shallow ref containing the initial value.\n *\n * @example\n * ```ts\n * import { useRef } from '@pastweb/vue';\n *\n * const element = useRef<HTMLElement | null>(null);\n * element.value?.focus();\n * ```\n */\nexport function useRef<T>(value?: T): Ref<T | undefined> {\n  return shallowRef(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,OAAU,OAA+B;CACvD,QAAA,GAAA,IAAA,WAAA,CAAkB,KAAK;AACzB"}

package/dist/useRef/useRef.d.cts

@@ -0,0 +1,25 @@
+import { Ref } from "vue";
+
+//#region src/useRef/useRef.d.ts
+/**
+ * Creates a Vue `shallowRef` with Pastweb's cross-framework ref naming.
+ *
+ * The returned value is a normal Vue ref, so consumers read and write through
+ * `.value`. Because it is shallow, assigning a new value is reactive, while
+ * nested object mutation is not deeply tracked by this helper.
+ *
+ * @param value - Optional initial ref value.
+ * @returns Vue shallow ref containing the initial value.
+ *
+ * @example
+ * ```ts
+ * import { useRef } from '@pastweb/vue';
+ *
+ * const element = useRef<HTMLElement | null>(null);
+ * element.value?.focus();
+ * ```
+ */
+declare function useRef<T>(value?: T): Ref<T | undefined>;
+//#endregion
+export { useRef };
+//# sourceMappingURL=useRef.d.cts.map

package/dist/useRef/useRef.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from "vue";
+
+//#region src/useRef/useRef.d.ts
+/**
+ * Creates a Vue `shallowRef` with Pastweb's cross-framework ref naming.
+ *
+ * The returned value is a normal Vue ref, so consumers read and write through
+ * `.value`. Because it is shallow, assigning a new value is reactive, while
+ * nested object mutation is not deeply tracked by this helper.
+ *
+ * @param value - Optional initial ref value.
+ * @returns Vue shallow ref containing the initial value.
+ *
+ * @example
+ * ```ts
+ * import { useRef } from '@pastweb/vue';
+ *
+ * const element = useRef<HTMLElement | null>(null);
+ * element.value?.focus();
+ * ```
+ */
+declare function useRef<T>(value?: T): Ref<T | undefined>;
+//#endregion
+export { useRef };
+//# sourceMappingURL=useRef.d.ts.map

package/dist/useRef/useRef.js

@@ -0,0 +1,27 @@
+import { shallowRef } from "vue";
+//#region src/useRef/useRef.ts
+/**
+* Creates a Vue `shallowRef` with Pastweb's cross-framework ref naming.
+*
+* The returned value is a normal Vue ref, so consumers read and write through
+* `.value`. Because it is shallow, assigning a new value is reactive, while
+* nested object mutation is not deeply tracked by this helper.
+*
+* @param value - Optional initial ref value.
+* @returns Vue shallow ref containing the initial value.
+*
+* @example
+* ```ts
+* import { useRef } from '@pastweb/vue';
+*
+* const element = useRef<HTMLElement | null>(null);
+* element.value?.focus();
+* ```
+*/
+function useRef(value) {
+	return shallowRef(value);
+}
+//#endregion
+export { useRef };
+
+//# sourceMappingURL=useRef.js.map

package/dist/useRef/useRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRef.js","names":[],"sources":["../../src/useRef/useRef.ts"],"sourcesContent":["import { shallowRef, type Ref } from 'vue';\n\n/**\n * Creates a Vue `shallowRef` with Pastweb's cross-framework ref naming.\n *\n * The returned value is a normal Vue ref, so consumers read and write through\n * `.value`. Because it is shallow, assigning a new value is reactive, while\n * nested object mutation is not deeply tracked by this helper.\n *\n * @param value - Optional initial ref value.\n * @returns Vue shallow ref containing the initial value.\n *\n * @example\n * ```ts\n * import { useRef } from '@pastweb/vue';\n *\n * const element = useRef<HTMLElement | null>(null);\n * element.value?.focus();\n * ```\n */\nexport function useRef<T>(value?: T): Ref<T | undefined> {\n  return shallowRef(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,OAAU,OAA+B;CACvD,OAAO,WAAW,KAAK;AACzB"}

package/dist/withDefaultProps/constants.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/withDefaultProps/constants.ts
+const OPTIONS = {
+	booleanChars: ["+", "-"],
+	className: true
+};
+//#endregion
+exports.OPTIONS = OPTIONS;
+
+//# sourceMappingURL=constants.cjs.map

package/dist/withDefaultProps/constants.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.cjs","names":[],"sources":["../../src/withDefaultProps/constants.ts"],"sourcesContent":["export const OPTIONS = {\n  booleanChars: ['+', '-'],\n  className: true,\n};\n"],"mappings":";;AAAA,MAAa,UAAU;CACrB,cAAc,CAAC,KAAK,GAAG;CACvB,WAAW;AACb"}

package/dist/withDefaultProps/constants.d.cts

@@ -0,0 +1,8 @@
+//#region src/withDefaultProps/constants.d.ts
+declare const OPTIONS: {
+  booleanChars: string[];
+  className: boolean;
+};
+//#endregion
+export { OPTIONS };
+//# sourceMappingURL=constants.d.cts.map

package/dist/withDefaultProps/constants.d.ts

@@ -0,0 +1,8 @@
+//#region src/withDefaultProps/constants.d.ts
+declare const OPTIONS: {
+  booleanChars: string[];
+  className: boolean;
+};
+//#endregion
+export { OPTIONS };
+//# sourceMappingURL=constants.d.ts.map

package/dist/withDefaultProps/constants.js

@@ -0,0 +1,9 @@
+//#region src/withDefaultProps/constants.ts
+const OPTIONS = {
+	booleanChars: ["+", "-"],
+	className: true
+};
+//#endregion
+export { OPTIONS };
+
+//# sourceMappingURL=constants.js.map

package/dist/withDefaultProps/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../src/withDefaultProps/constants.ts"],"sourcesContent":["export const OPTIONS = {\n  booleanChars: ['+', '-'],\n  className: true,\n};\n"],"mappings":";AAAA,MAAa,UAAU;CACrB,cAAc,CAAC,KAAK,GAAG;CACvB,WAAW;AACb"}

package/dist/withDefaultProps/index.cjs

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

package/dist/withDefaultProps/index.d.cts

@@ -0,0 +1,3 @@
+import { WithDefaultPropsOptions } from "./types.cjs";
+import { withDefaultProps } from "./withDefaultProps.cjs";
+export { type WithDefaultPropsOptions, withDefaultProps };

package/dist/withDefaultProps/index.d.ts

@@ -0,0 +1,3 @@
+import { WithDefaultPropsOptions } from "./types.js";
+import { withDefaultProps } from "./withDefaultProps.js";
+export { type WithDefaultPropsOptions, withDefaultProps };

package/dist/withDefaultProps/index.js

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

package/dist/withDefaultProps/types.d.cts

@@ -0,0 +1,25 @@
+//#region src/withDefaultProps/types.d.ts
+/**
+ * Options controlling Vue prop default normalization.
+ */
+interface WithDefaultPropsOptions {
+  /**
+   * String pair converted to boolean `true` and `false`.
+   *
+   * Useful because Vue coerces absent Boolean props to `false`, so string
+   * markers preserve the difference between "unset" and "explicit false" until
+   * defaults have been applied. Defaults to `['+', '-']`.
+   */
+  booleanChars?: [string, string];
+  /** When true, maps a default key named `className` to Vue's `class` prop. */
+  className?: boolean;
+  /**
+   * Keys to exclude from default merging.
+   * Can be a string, RegExp, or array of both.
+   * Applied to the original key name from the `defaults` object.
+   */
+  exclude?: string | RegExp | Array<string | RegExp>;
+}
+//#endregion
+export { WithDefaultPropsOptions };
+//# sourceMappingURL=types.d.cts.map

package/dist/withDefaultProps/types.d.ts

@@ -0,0 +1,25 @@
+//#region src/withDefaultProps/types.d.ts
+/**
+ * Options controlling Vue prop default normalization.
+ */
+interface WithDefaultPropsOptions {
+  /**
+   * String pair converted to boolean `true` and `false`.
+   *
+   * Useful because Vue coerces absent Boolean props to `false`, so string
+   * markers preserve the difference between "unset" and "explicit false" until
+   * defaults have been applied. Defaults to `['+', '-']`.
+   */
+  booleanChars?: [string, string];
+  /** When true, maps a default key named `className` to Vue's `class` prop. */
+  className?: boolean;
+  /**
+   * Keys to exclude from default merging.
+   * Can be a string, RegExp, or array of both.
+   * Applied to the original key name from the `defaults` object.
+   */
+  exclude?: string | RegExp | Array<string | RegExp>;
+}
+//#endregion
+export { WithDefaultPropsOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/withDefaultProps/withDefaultProps.cjs

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_withDefaultProps_constants = require("./constants.cjs");
+let vue = require("vue");
+let _pastweb_tools_update = require("@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 = {
+		...require_withDefaultProps_constants.OPTIONS,
+		...options
+	};
+	const { booleanChars: [trueChar, falseChar] } = opts;
+	const excludes = Array.isArray(opts.exclude) ? opts.exclude : [opts.exclude];
+	const newProps = (0, vue.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;
+		});
+	};
+	(0, vue.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;
+		});
+		(0, _pastweb_tools_update.update)(newProps, merged);
+	});
+	return newProps;
+}
+//#endregion
+exports.withDefaultProps = withDefaultProps;
+
+//# sourceMappingURL=withDefaultProps.cjs.map

package/dist/withDefaultProps/withDefaultProps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDefaultProps.cjs","names":["OPTIONS"],"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,GAAGA,mCAAAA;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,YAAA,GAAA,IAAA,gBAAA,CAAgD,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,CAAA,GAAA,IAAA,YAAA,OAAkB;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,CAAA,GAAA,sBAAA,OAAA,CAAO,UAAU,MAAM;CACzB,CAAC;CAED,OAAO;AACT"}

package/dist/withDefaultProps/withDefaultProps.d.cts

@@ -0,0 +1,48 @@
+import { WithDefaultPropsOptions } from "./types.cjs";
+
+//#region src/withDefaultProps/withDefaultProps.d.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/] }
+ * );
+ * ```
+ */
+declare function withDefaultProps<T>(props: Record<string, any>, defaults: Record<string, any>, options?: WithDefaultPropsOptions): T;
+//#endregion
+export { withDefaultProps };
+//# sourceMappingURL=withDefaultProps.d.cts.map

package/dist/withDefaultProps/withDefaultProps.d.ts

@@ -0,0 +1,48 @@
+import { WithDefaultPropsOptions } from "./types.js";
+
+//#region src/withDefaultProps/withDefaultProps.d.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/] }
+ * );
+ * ```
+ */
+declare function withDefaultProps<T>(props: Record<string, any>, defaults: Record<string, any>, options?: WithDefaultPropsOptions): T;
+//#endregion
+export { withDefaultProps };
+//# sourceMappingURL=withDefaultProps.d.ts.map