@dnd-kit/vue 0.2.3

package/utilities.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utilities/index.ts
+var utilities_exports = {};
+__export(utilities_exports, {
+  createContext: () => createContext,
+  toValueDeep: () => toValueDeep,
+  unrefElement: () => unrefElement
+});
+module.exports = __toCommonJS(utilities_exports);
+
+// src/utilities/context.ts
+var import_vue = require("vue");
+function createContext(componentName) {
+  const injectionKey = Symbol(
+    `${componentName}Context`
+  );
+  return [injectContext, provideContext];
+  function injectContext(fallback) {
+    const context = (0, import_vue.inject)(injectionKey, fallback);
+    if (context) return context;
+    if (context === null) return context;
+    throw new Error(
+      `Injection \`${injectionKey.toString()}\` not found. Component must be used within \`${componentName}\``
+    );
+  }
+  function provideContext(contextValue) {
+    (0, import_vue.provide)(injectionKey, contextValue);
+    return contextValue;
+  }
+}
+
+// src/utilities/element.ts
+var import_vue2 = require("vue");
+function unrefElement(elRef) {
+  const plain = (0, import_vue2.toValue)(elRef);
+  return plain?.$el ?? plain ?? void 0;
+}
+
+// src/utilities/ref.ts
+var import_vue3 = require("vue");
+function toValueDeep(input) {
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key, (0, import_vue3.toValue)(value)])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  toValueDeep,
+  unrefElement
+});
+//# sourceMappingURL=utilities.cjs.map

package/utilities.d.ts

@@ -0,0 +1,15 @@
+import { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
+
+declare function createContext<TContextValue>(componentName: string): readonly [<T extends TContextValue | null | undefined = TContextValue>(fallback?: T) => T extends null ? TContextValue | null : TContextValue, (contextValue: TContextValue) => TContextValue];
+
+type MaybeRefsOrGetters<T> = {
+    [K in keyof T]: MaybeRefOrGetter<T[K]>;
+};
+type MaybeElement = HTMLElement | ComponentPublicInstance | undefined | null;
+
+type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends ComponentPublicInstance ? Exclude<MaybeElement, ComponentPublicInstance | null> : Exclude<T, null> | undefined;
+declare function unrefElement<T extends MaybeElement>(elRef: MaybeRefOrGetter<T>): UnRefElementReturn<T>;
+
+declare function toValueDeep<T>(input: MaybeRefsOrGetters<T>): T;
+
+export { type UnRefElementReturn, createContext, toValueDeep, unrefElement };

package/utilities.js

@@ -0,0 +1,41 @@
+// src/utilities/context.ts
+import { inject, provide } from "vue";
+function createContext(componentName) {
+  const injectionKey = Symbol(
+    `${componentName}Context`
+  );
+  return [injectContext, provideContext];
+  function injectContext(fallback) {
+    const context = inject(injectionKey, fallback);
+    if (context) return context;
+    if (context === null) return context;
+    throw new Error(
+      `Injection \`${injectionKey.toString()}\` not found. Component must be used within \`${componentName}\``
+    );
+  }
+  function provideContext(contextValue) {
+    provide(injectionKey, contextValue);
+    return contextValue;
+  }
+}
+
+// src/utilities/element.ts
+import { toValue } from "vue";
+function unrefElement(elRef) {
+  const plain = toValue(elRef);
+  return plain?.$el ?? plain ?? void 0;
+}
+
+// src/utilities/ref.ts
+import { toValue as toValue2 } from "vue";
+function toValueDeep(input) {
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key, toValue2(value)])
+  );
+}
+export {
+  createContext,
+  toValueDeep,
+  unrefElement
+};
+//# sourceMappingURL=utilities.js.map