@ansh-ui/vue 0.2.0

package/dist/utils-IKPG3zcC.d.cts

@@ -0,0 +1,46 @@
+import { VNodeChild, Ref, ComputedRef } from 'vue';
+
+/**
+ * A ref that is only ever read, never written, by the primitive that accepts it.
+ *
+ * `useControllableState` returns a `ComputedRef` — read-only by design, so a component can't
+ * accidentally mutate state that might be owned by a parent. Every primitive below (`useDismiss`,
+ * `useFocusTrap`, `usePresence`, …) only ever reads its `open`/`active` argument, so it accepts
+ * either. Typing those parameters as plain `Ref<T>` would reject a `ComputedRef<T>` at the call
+ * site — TypeScript treats `{ readonly value: T }` as not assignable to `{ value: T }` — which would
+ * force every overlay component to unwrap and re-wrap its own open state for no behavioural reason.
+ */
+type ReadonlyRef<T> = Ref<T> | ComputedRef<T>;
+/**
+ * A prop that accepts a string, a VNode tree, or a render function — for `label`, `description`,
+ * `error` and similar content props across the form and overlay components.
+ *
+ * Vue's own `VNodeChild` type does not include a bare function, so `PropType<VNodeChild>` narrows
+ * `typeof x === 'function'` to `never` and the call site fails to typecheck. Accepting a function
+ * here is what lets a caller pass reactive, computed content (`:label="() => \`\${count} items\`"`)
+ * without wrapping it in a render-prop-shaped slot.
+ */
+type SlotContent = VNodeChild | (() => VNodeChild);
+/**
+ * Resolve a {@link SlotContent} prop to a renderable value.
+ *
+ * Pass the result to `h()` wrapped in an array — `h('p', {}, [resolveSlotContent(x)])`, not
+ * `h('p', {}, resolveSlotContent(x))`. The bare (non-array) children overload of `h()` doesn't
+ * accept a value that includes `null` in its type, which every `SlotContent` does.
+ */
+declare function resolveSlotContent(value: SlotContent | undefined): VNodeChild;
+/** Join class names, dropping falsy entries. The whole of `clsx` that this library actually uses. */
+declare function cx(...parts: Array<string | false | null | undefined>): string;
+/**
+ * A stable id, unique per component instance.
+ *
+ * Vue 3.5 ships a built-in `useId()` solving exactly this; the peer range here is `^3.4.0`, so this
+ * exists for the versions before that. `getCurrentInstance().uid` is used rather than a random
+ * value because it is **deterministic**: Vue assigns uids in creation order, and a matching
+ * server/client tree creates its components in the same order on both sides, so the id a control
+ * renders with during SSR is the id it hydrates with. A random or counter-reset-per-request value
+ * would mismatch and force a client re-render of every id-bearing attribute.
+ */
+declare function useId(prefix?: string): string;
+
+export { type ReadonlyRef as R, type SlotContent as S, cx as c, resolveSlotContent as r, useId as u };

package/dist/utils-IKPG3zcC.d.ts

@@ -0,0 +1,46 @@
+import { VNodeChild, Ref, ComputedRef } from 'vue';
+
+/**
+ * A ref that is only ever read, never written, by the primitive that accepts it.
+ *
+ * `useControllableState` returns a `ComputedRef` — read-only by design, so a component can't
+ * accidentally mutate state that might be owned by a parent. Every primitive below (`useDismiss`,
+ * `useFocusTrap`, `usePresence`, …) only ever reads its `open`/`active` argument, so it accepts
+ * either. Typing those parameters as plain `Ref<T>` would reject a `ComputedRef<T>` at the call
+ * site — TypeScript treats `{ readonly value: T }` as not assignable to `{ value: T }` — which would
+ * force every overlay component to unwrap and re-wrap its own open state for no behavioural reason.
+ */
+type ReadonlyRef<T> = Ref<T> | ComputedRef<T>;
+/**
+ * A prop that accepts a string, a VNode tree, or a render function — for `label`, `description`,
+ * `error` and similar content props across the form and overlay components.
+ *
+ * Vue's own `VNodeChild` type does not include a bare function, so `PropType<VNodeChild>` narrows
+ * `typeof x === 'function'` to `never` and the call site fails to typecheck. Accepting a function
+ * here is what lets a caller pass reactive, computed content (`:label="() => \`\${count} items\`"`)
+ * without wrapping it in a render-prop-shaped slot.
+ */
+type SlotContent = VNodeChild | (() => VNodeChild);
+/**
+ * Resolve a {@link SlotContent} prop to a renderable value.
+ *
+ * Pass the result to `h()` wrapped in an array — `h('p', {}, [resolveSlotContent(x)])`, not
+ * `h('p', {}, resolveSlotContent(x))`. The bare (non-array) children overload of `h()` doesn't
+ * accept a value that includes `null` in its type, which every `SlotContent` does.
+ */
+declare function resolveSlotContent(value: SlotContent | undefined): VNodeChild;
+/** Join class names, dropping falsy entries. The whole of `clsx` that this library actually uses. */
+declare function cx(...parts: Array<string | false | null | undefined>): string;
+/**
+ * A stable id, unique per component instance.
+ *
+ * Vue 3.5 ships a built-in `useId()` solving exactly this; the peer range here is `^3.4.0`, so this
+ * exists for the versions before that. `getCurrentInstance().uid` is used rather than a random
+ * value because it is **deterministic**: Vue assigns uids in creation order, and a matching
+ * server/client tree creates its components in the same order on both sides, so the id a control
+ * renders with during SSR is the id it hydrates with. A random or counter-reset-per-request value
+ * would mismatch and force a client re-render of every id-bearing attribute.
+ */
+declare function useId(prefix?: string): string;
+
+export { type ReadonlyRef as R, type SlotContent as S, cx as c, resolveSlotContent as r, useId as u };

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@ansh-ui/vue",
+  "version": "0.2.0",
+  "description": "Ansh for Vue 3 and Nuxt — premium animated components and motion composables.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "keywords": [
+    "vue",
+    "vue3",
+    "nuxt",
+    "animation",
+    "motion",
+    "components",
+    "ui",
+    "canvas"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jithin003/ui-library.git",
+    "directory": "packages/vue"
+  },
+  "homepage": "https://github.com/jithin003/ui-library",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./primitives": {
+      "types": "./dist/primitives.d.ts",
+      "import": "./dist/primitives.js",
+      "require": "./dist/primitives.cjs"
+    },
+    "./layout": {
+      "types": "./dist/layout.d.ts",
+      "import": "./dist/layout.js",
+      "require": "./dist/layout.cjs"
+    },
+    "./form": {
+      "types": "./dist/form.d.ts",
+      "import": "./dist/form.js",
+      "require": "./dist/form.cjs"
+    },
+    "./overlay": {
+      "types": "./dist/overlay.d.ts",
+      "import": "./dist/overlay.js",
+      "require": "./dist/overlay.cjs"
+    },
+    "./data": {
+      "types": "./dist/data.d.ts",
+      "import": "./dist/data.js",
+      "require": "./dist/data.cjs"
+    },
+    "./navigation": {
+      "types": "./dist/navigation.d.ts",
+      "import": "./dist/navigation.js",
+      "require": "./dist/navigation.cjs"
+    },
+    "./motion": {
+      "types": "./dist/motion.d.ts",
+      "import": "./dist/motion.js",
+      "require": "./dist/motion.cjs"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@ansh-ui/core": "0.2.0",
+    "@ansh-ui/tokens": "0.2.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup && node ./scripts/build-css.mjs",
+    "dev": "tsup --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}