buefy 1.0.0 → 1.0.2

package/dist/esm/timepicker.js

@@ -0,0 +1,24 @@
+import { T as Timepicker } from './Timepicker-DnkqnOBT.js';
+import { a as registerComponent } from './plugins-B172kuKE.js';
+import 'vue';
+import './TimepickerMixin-Bikh6_Fg.js';
+import './CompatFallthroughMixin-C8LPuwDr.js';
+import './config-CKuo-p6e.js';
+import './FormElementMixin-Dd_wkBN5.js';
+import './helpers.js';
+import './Dropdown-CGTYVyoL.js';
+import './trapFocus-KHP_kCNE.js';
+import './_plugin-vue_export-helper-OJRSZE6i.js';
+import './DropdownItem-Cn3nM0A3.js';
+import './Input-C4L520az.js';
+import './Icon-DPyGDeRK.js';
+import './Field-B7bX_uUg.js';
+import './Select-bl4qUzij.js';
+
+const Plugin = {
+  install(Vue) {
+    registerComponent(Vue, Timepicker);
+  }
+};
+
+export { Timepicker as BTimepicker, Plugin as default };

package/dist/esm/toast.js

@@ -0,0 +1,156 @@
+import { defineComponent, createBlock, openBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, renderSlot, createElementBlock, Fragment, createCommentVNode, vShow, createApp, h } from 'vue';
+import { c as config } from './config-CKuo-p6e.js';
+import { N as NoticeMixin } from './NoticeMixin-ByNlva3T.js';
+import { _ as _export_sfc } from './_plugin-vue_export-helper-OJRSZE6i.js';
+import { getComponentFromVNode, copyAppContext } from './helpers.js';
+import { r as registerComponentProgrammatic } from './plugins-B172kuKE.js';
+
+const Toast$1 = defineComponent({
+  name: "BToast",
+  mixins: [NoticeMixin],
+  data() {
+    return {
+      newDuration: this.duration || config.defaultToastDuration
+    };
+  }
+});
+
+const _hoisted_1 = ["aria-hidden"];
+const _hoisted_2 = ["innerHTML"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createBlock(Transition, {
+    "enter-active-class": _ctx.transition.enter,
+    "leave-active-class": _ctx.transition.leave,
+    persisted: ""
+  }, {
+    default: withCtx(() => [
+      withDirectives(createElementVNode("div", {
+        onMouseenter: _cache[0] || (_cache[0] = (...args) => _ctx.pause && _ctx.pause(...args)),
+        onMouseleave: _cache[1] || (_cache[1] = (...args) => _ctx.removePause && _ctx.removePause(...args)),
+        class: normalizeClass(["toast", [_ctx.type, _ctx.position]]),
+        "aria-hidden": !_ctx.isActive,
+        role: "alert"
+      }, [
+        _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createElementBlock(
+          Fragment,
+          { key: 1 },
+          [
+            createCommentVNode(" eslint-disable-next-line vue/no-v-html "),
+            createElementVNode("div", { innerHTML: _ctx.message }, null, 8, _hoisted_2)
+          ],
+          64
+          /* STABLE_FRAGMENT */
+        ))
+      ], 42, _hoisted_1), [
+        [vShow, _ctx.isActive]
+      ])
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 8, ["enter-active-class", "leave-active-class"]);
+}
+var Toast = /* @__PURE__ */ _export_sfc(Toast$1, [["render", _sfc_render]]);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+class ToastProgrammatic {
+  constructor(app) {
+    __publicField(this, "app");
+    this.app = app;
+  }
+  open(params) {
+    if (typeof params === "string") {
+      params = {
+        message: params
+      };
+    }
+    let slot;
+    let _a = params, { message } = _a, restParams = __objRest(_a, ["message"]);
+    if (typeof message !== "string") {
+      slot = message;
+      message = void 0;
+    }
+    const propsData = __spreadValues({
+      position: config.defaultToastPosition || "is-top",
+      message
+    }, restParams);
+    const container = document.createElement("div");
+    const vueInstance = createApp({
+      data() {
+        return {
+          toastVNode: null
+        };
+      },
+      methods: {
+        close() {
+          const toast = getComponentFromVNode(this.toastVNode);
+          if (toast) {
+            toast.close();
+          }
+        }
+      },
+      render() {
+        this.toastVNode = h(
+          Toast,
+          __spreadProps(__spreadValues({}, propsData), {
+            // On Vue 3, $destroy is no longer available.
+            // A toast has to be unmounted manually.
+            onClose: () => {
+              if (typeof propsData.onClose === "function") {
+                propsData.onClose();
+              }
+              setTimeout(() => {
+                vueInstance.unmount();
+              }, 150);
+            }
+          }),
+          slot != null ? { default: () => slot } : void 0
+        );
+        return this.toastVNode;
+      }
+    });
+    if (this.app) {
+      copyAppContext(this.app, vueInstance);
+    } else {
+      vueInstance.config.globalProperties.$buefy = {};
+    }
+    return vueInstance.mount(container);
+  }
+}
+const Plugin = {
+  install(Vue) {
+    registerComponentProgrammatic(Vue, "toast", new ToastProgrammatic(Vue));
+  }
+};
+
+export { Toast as BToast, ToastProgrammatic, Plugin as default };

package/dist/esm/tooltip.js

@@ -0,0 +1,14 @@
+import { T as Tooltip } from './Tooltip-CtDSXAqa.js';
+import { a as registerComponent } from './plugins-B172kuKE.js';
+import 'vue';
+import './config-CKuo-p6e.js';
+import './helpers.js';
+import './_plugin-vue_export-helper-OJRSZE6i.js';
+
+const Plugin = {
+  install(Vue) {
+    registerComponent(Vue, Tooltip);
+  }
+};
+
+export { Tooltip as BTooltip, Plugin as default };

package/dist/esm/trapFocus-KHP_kCNE.js

@@ -0,0 +1,51 @@
+const findFocusable = (element, programmatic = false) => {
+  if (!element) {
+    return null;
+  }
+  if (programmatic) {
+    return element.querySelectorAll('*[tabindex="-1"]');
+  }
+  return element.querySelectorAll(`a[href]:not([tabindex="-1"]),
+                                     area[href],
+                                     input:not([disabled]),
+                                     select:not([disabled]),
+                                     textarea:not([disabled]),
+                                     button:not([disabled]),
+                                     iframe,
+                                     object,
+                                     embed,
+                                     *[tabindex]:not([tabindex="-1"]),
+                                     *[contenteditable]`);
+};
+let onKeyDown;
+const beforeMount = (el, { value = true }) => {
+  if (value) {
+    let focusable = findFocusable(el);
+    let focusableProg = findFocusable(el, true);
+    if (focusable && focusable.length > 0) {
+      onKeyDown = (event) => {
+        focusable = findFocusable(el);
+        focusableProg = findFocusable(el, true);
+        const firstFocusable = focusable[0];
+        const lastFocusable = focusable[focusable.length - 1];
+        if (event.target === firstFocusable && event.shiftKey && event.key === "Tab") {
+          event.preventDefault();
+          lastFocusable.focus();
+        } else if ((event.target === lastFocusable || Array.from(focusableProg).indexOf(event.target) >= 0) && !event.shiftKey && event.key === "Tab") {
+          event.preventDefault();
+          firstFocusable.focus();
+        }
+      };
+      el.addEventListener("keydown", onKeyDown);
+    }
+  }
+};
+const unmounted = (el) => {
+  el.removeEventListener("keydown", onKeyDown);
+};
+const directive = {
+  beforeMount,
+  unmounted
+};
+
+export { directive as d };

package/dist/esm/upload.js

@@ -0,0 +1,190 @@
+import { defineComponent, createElementBlock, openBlock, mergeProps, renderSlot, createElementVNode, withModifiers, normalizeClass } from 'vue';
+import { C as CompatFallthroughMixin } from './CompatFallthroughMixin-C8LPuwDr.js';
+import { F as FormElementMixin } from './FormElementMixin-Dd_wkBN5.js';
+import { F as File } from './ssr-C7yEpGLm.js';
+import { _ as _export_sfc } from './_plugin-vue_export-helper-OJRSZE6i.js';
+import { a as registerComponent } from './plugins-B172kuKE.js';
+import './config-CKuo-p6e.js';
+
+const Upload$1 = defineComponent({
+  name: "BUpload",
+  mixins: [CompatFallthroughMixin, FormElementMixin],
+  props: {
+    modelValue: {
+      type: [Object, Function, File, Array]
+    },
+    multiple: Boolean,
+    disabled: Boolean,
+    accept: String,
+    dragDrop: Boolean,
+    type: {
+      type: String,
+      default: "is-primary"
+    },
+    native: {
+      type: Boolean,
+      default: false
+    },
+    expanded: {
+      type: Boolean,
+      default: false
+    },
+    rounded: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: {
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    invalid: () => true,
+    "update:modelValue": (newValue) => true
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  },
+  data() {
+    return {
+      newValue: this.modelValue,
+      dragDropFocus: false,
+      _elementRef: "input"
+    };
+  },
+  computed: {
+    disabledOrUndefined() {
+      return this.disabled || void 0;
+    }
+  },
+  watch: {
+    modelValue(value) {
+      this.newValue = value;
+      if (!value || Array.isArray(value) && value.length === 0) {
+        this.$refs.input.value = "";
+      }
+      !this.isValid && !this.dragDrop && this.checkHtml5Validity();
+    }
+  },
+  methods: {
+    onFileChange(event) {
+      var _a, _b;
+      if (this.disabled || this.loading) return;
+      if (this.dragDrop) this.updateDragDropFocus(false);
+      const value = (_b = (_a = event.target.files) != null ? _a : event.dataTransfer.files) != null ? _b : [];
+      if (value.length === 0) {
+        if (!this.newValue) return;
+        if (this.native) this.newValue = null;
+      } else if (!this.multiple) {
+        if (this.dragDrop && value.length !== 1) return;
+        else {
+          const file = value[0];
+          if (this.checkType(file)) this.newValue = file;
+          else if (this.newValue) {
+            this.newValue = null;
+            this.clearInput();
+          } else {
+            this.clearInput();
+            this.checkHtml5Validity();
+            return;
+          }
+        }
+      } else {
+        let newValues = false;
+        if (this.native || !this.newValue) {
+          this.newValue = [];
+          newValues = true;
+        }
+        for (let i = 0; i < value.length; i++) {
+          const file = value[i];
+          if (this.checkType(file) && Array.isArray(this.newValue)) {
+            this.newValue.push(file);
+            newValues = true;
+          }
+        }
+        if (!newValues) return;
+      }
+      this.$emit("update:modelValue", this.newValue);
+      !this.dragDrop && this.checkHtml5Validity();
+    },
+    clearInput() {
+      this.$refs.input.value = "";
+    },
+    updateDragDropFocus(focus) {
+      if (!this.disabled && !this.loading) {
+        this.dragDropFocus = focus;
+      }
+    },
+    checkType(file) {
+      if (!this.accept) return true;
+      const types = this.accept.split(",");
+      if (types.length === 0) return true;
+      let valid = false;
+      for (let i = 0; i < types.length && !valid; i++) {
+        const type = types[i].trim();
+        if (type) {
+          if (type.substring(0, 1) === ".") {
+            const extension = file.name.toLowerCase().slice(-type.length);
+            if (extension === type.toLowerCase()) {
+              valid = true;
+            }
+          } else {
+            if (file.type.match(type)) {
+              valid = true;
+            }
+          }
+        }
+      }
+      if (!valid) this.$emit("invalid");
+      return valid;
+    }
+  }
+});
+
+const _hoisted_1 = ["multiple", "accept", "disabled"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock(
+    "label",
+    mergeProps({ class: "upload control" }, _ctx.rootAttrs, {
+      class: [{ "is-expanded": _ctx.expanded, "is-rounded": _ctx.rounded }]
+    }),
+    [
+      !_ctx.dragDrop ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createElementBlock(
+        "div",
+        {
+          key: 1,
+          class: normalizeClass(["upload-draggable", [_ctx.type, {
+            "is-loading": _ctx.loading,
+            "is-disabled": _ctx.disabled,
+            "is-hovered": _ctx.dragDropFocus,
+            "is-expanded": _ctx.expanded
+          }]]),
+          onDragover: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.updateDragDropFocus(true), ["prevent"])),
+          onDragleave: _cache[1] || (_cache[1] = withModifiers(($event) => _ctx.updateDragDropFocus(false), ["prevent"])),
+          onDragenter: _cache[2] || (_cache[2] = withModifiers(($event) => _ctx.updateDragDropFocus(true), ["prevent"])),
+          onDrop: _cache[3] || (_cache[3] = withModifiers((...args) => _ctx.onFileChange && _ctx.onFileChange(...args), ["prevent"]))
+        },
+        [
+          renderSlot(_ctx.$slots, "default")
+        ],
+        34
+        /* CLASS, NEED_HYDRATION */
+      )),
+      createElementVNode("input", mergeProps({
+        ref: "input",
+        type: "file"
+      }, _ctx.fallthroughAttrs, {
+        multiple: _ctx.multiple,
+        accept: _ctx.accept,
+        disabled: _ctx.disabledOrUndefined,
+        onChange: _cache[4] || (_cache[4] = (...args) => _ctx.onFileChange && _ctx.onFileChange(...args))
+      }), null, 16, _hoisted_1)
+    ],
+    16
+    /* FULL_PROPS */
+  );
+}
+var Upload = /* @__PURE__ */ _export_sfc(Upload$1, [["render", _sfc_render]]);
+
+const Plugin = {
+  install(Vue) {
+    registerComponent(Vue, Upload);
+  }
+};
+
+export { Upload as BUpload, Plugin as default };

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.52.8"
+    }
+  ]
+}

package/package.json

@@ -1,11 +1,78 @@
 {
   "name": "buefy",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "1.0.2",
+  "description": "Lightweight UI components for Vue.js (v3) based on Bulma",
+  "keywords": [
+    "vuejs",
+    "bulma",
+    "buefy",
+    "nodejs",
+    "components-library",
+    "open-source",
+    "css",
+    "scss",
+    "typescript"
+  ],
+  "author": "Rafael Beraldo <rafael.pimpa@gmail.com>",
+  "maintainers": [
+    "Kikuo Emoto <kemoto@codemonger.io>",
+    "Wesley Ford <wes@wesdevpro.com>"
+  ],
+  "homepage": "https://buefy.org",
+  "license": "MIT",
+  "main": "dist/cjs/index.js",
+  "module": "dist/buefy.esm.js",
+  "unpkg": "dist/buefy.min.js",
+  "typings": "dist/buefy.d.ts",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ],
+  "files": [
+    "dist",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/buefy/buefy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/buefy/buefy/issues"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "npm run lint && npm run unit:update",
+    "unit": "vitest --run",
+    "unit:update": "vitest -u --run",
+    "lint": "eslint src --ext .js,.ts,.vue",
+    "lint:fix": "eslint src --ext .js,.ts,.vue --fix",
+    "type-check": "vue-tsc --noEmit -p tsconfig.test.json --composite false",
+    "build": "rimraf dist && npm run build:js && npm run build:scss && npm run build:dts",
+    "build:js": "rollup -c && rollup -c --environment MINIFY",
+    "build:dts": "rimraf temp-dts && vue-tsc -b tsconfig.types.json --force && api-extractor run --local && node build/augment-dts.mjs",
+    "build:scss": "node ./build/banner.js < src/scss/buefy-build.scss | sass --stdin --load-path src/scss > dist/buefy.css && cleancss -o dist/buefy.min.css dist/buefy.css"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "@babel/plugin-transform-runtime": "^7.26.9",
+    "@babel/preset-env": "^7.26.9",
+    "@microsoft/api-extractor": "^7.50.0",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@types/jsdom": "^21.1.7",
+    "@vue/test-utils": "^2.4.6",
+    "clean-css-cli": "^5.6.2",
+    "esm": "^3.2.25",
+    "jsdom": "^26.0.0",
+    "rimraf": "^5.0.10",
+    "rollup-plugin-esbuild": "^6.1.0",
+    "vitest": "^3.0.6"
   },
-  "author": "",
-  "license": "MIT"
+  "dependencies": {
+    "bulma": "^0.9.4"
+  }
 }