@king-design/vue 2.0.0-beta.0

package/components/select/useLabel.js

@@ -0,0 +1,59 @@
+import { useInstance, createRef } from 'intact-vue-next';
+import { isNullOrUndefined, EMPTY_OBJ } from 'intact-shared';
+import { findChildren, isComponentVNode } from '../utils';
+import { Option } from './option';
+import { OptionGroup } from './group';
+import { useBaseLabel } from './useBaseLabel';
+export function useLabel() {
+  var instance = useInstance();
+  var activeIndices = createRef([]);
+
+  var _useBaseLabel = useBaseLabel(function () {
+    return instance.get('children');
+  }, findLabel),
+      getLabel = _useBaseLabel.getLabel;
+
+  function findLabel(children, value) {
+    var label = null;
+    var index = 0;
+    activeIndices.value = [];
+
+    var loop = function loop(children) {
+      return findChildren(children, function (vNode) {
+        if (isComponentVNode(vNode, Option)) {
+          var props = vNode.props;
+          if (isNullOrUndefined(props)) return false;
+
+          if (props.value === value) {
+            label = props.label;
+
+            if (isNullOrUndefined(label)) {
+              label = props.children;
+            }
+
+            return true;
+          }
+        } else if (isComponentVNode(vNode, OptionGroup)) {
+          if (loop((vNode.props || EMPTY_OBJ).children)) {
+            activeIndices.value.push(index);
+            return true;
+          }
+
+          index++;
+        }
+
+        return false;
+      });
+    };
+
+    loop(children);
+    return label;
+  }
+
+  return {
+    getLabel: getLabel,
+    activeIndices: activeIndices
+  };
+}
+
+export {normalize} from 'intact-vue-next';

package/components/select/useSearchable.d.ts

@@ -0,0 +1,14 @@
+export declare const context: {
+    Provider: import('intact-vue-next').ComponentConstructor<import("intact").Component<import("../context").ProviderProps<any>, {}, {}, {}>>;
+    Consumer: import("intact").ComponentConstructor<import("intact").Component<{}, {}, {}, {}>>;
+};
+export declare function useSearchable(): {
+    checkedKeys: import("../../hooks/useState").State<any[]>;
+    selectAll: () => void;
+    unselectAll: () => void;
+    toggleSelect: () => void;
+    confirm: () => void;
+};
+
+
+export {normalize} from 'intact-vue-next';

package/components/select/useSearchable.js

@@ -0,0 +1,71 @@
+import _Array$from from "@babel/runtime-corejs3/core-js/array/from";
+import _Set from "@babel/runtime-corejs3/core-js/set";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js/instance/filter";
+import { useInstance } from 'intact-vue-next';
+import { useState } from '../../hooks/useState';
+import { isNullOrUndefined } from 'intact-shared';
+import { createContext } from '../context';
+export var context = createContext();
+export function useSearchable() {
+  var menu = useInstance();
+  var select = menu.select;
+  var checkedKeys = useState([]);
+
+  function selectAll() {
+    checkedKeys.set(addKeys(checkedKeys.value, menu.get('values')));
+  }
+
+  function unselectAll() {
+    checkedKeys.set(removeKeys(checkedKeys.value, menu.get('values')));
+  }
+
+  function toggleSelect() {
+    var checked = [];
+    var unchecked = [];
+    menu.get('values').forEach(function (item) {
+      if (checkedKeys.value.indexOf(item) > -1) {
+        checked.push(item);
+      } else {
+        unchecked.push(item);
+      }
+    });
+    checkedKeys.set(removeKeys(addKeys(checkedKeys.value, unchecked), checked));
+  }
+
+  function confirm() {
+    select.set('value', checkedKeys.value);
+    select.hide();
+  }
+
+  function initCheckedKeys() {
+    var value = select.get('value');
+    checkedKeys.set(isNullOrUndefined(value) ? [] : value);
+  }
+
+  select.watch('value', initCheckedKeys);
+  select.on('hide', initCheckedKeys);
+  return {
+    checkedKeys: checkedKeys,
+    selectAll: selectAll,
+    unselectAll: unselectAll,
+    toggleSelect: toggleSelect,
+    confirm: confirm
+  };
+}
+
+function addKeys(origin, keys) {
+  var _context;
+
+  return _Array$from(new _Set(_concatInstanceProperty(_context = []).call(_context, keys, origin || [])));
+}
+
+function removeKeys(origin, keys) {
+  var _context2;
+
+  return _filterInstanceProperty(_context2 = origin || []).call(_context2, function (item) {
+    return keys.indexOf(item) < 0;
+  });
+}
+
+export {normalize} from 'intact-vue-next';

package/components/slider/index.d.ts

@@ -0,0 +1,50 @@
+import { Component, TypeDefs } from 'intact-vue-next';
+import type { StepObject, StepFunction, SpinnerProps } from '../spinner';
+import type { TooltipProps } from '../tooltip';
+import { Value } from './useValue';
+import { Marks } from './useMarks';
+import type { Events } from '../types';
+export interface SliderProps<Range extends boolean = boolean> {
+    max?: number;
+    min?: number;
+    value?: Value<Range>;
+    range?: Range;
+    unit?: string;
+    showEnd?: boolean;
+    showInput?: boolean;
+    step?: number | StepObject | StepFunction;
+    points?: number[] | boolean;
+    marks?: Marks;
+    disabled?: boolean;
+    showTooltip?: boolean;
+    always?: boolean;
+    animate?: boolean;
+    tooltipProps?: TooltipProps;
+    spinnerProps?: SpinnerProps;
+    forceStep?: boolean;
+}
+export declare type SliderMarks = Marks;
+export interface SliderEvents<Range extends boolean = boolean> {
+    change: [Value<Range>, Value<Range>];
+}
+export interface SliderBlocks<Range extends boolean = boolean> {
+    tooltip: Value<Range>;
+}
+export declare class Slider<Range extends boolean = false> extends Component<SliderProps<Range>, SliderEvents<Range>, SliderBlocks<Range>> {
+    static template: string | import("intact").Template<any>;
+    static typeDefs: Required<TypeDefs<SliderProps<boolean>>>;
+    static defaults: () => Partial<SliderProps<boolean>>;
+    static events: Events<SliderEvents<boolean>>;
+    private step;
+    private value;
+    private tooltip;
+    private draggable;
+    private styles;
+    private keyboard;
+    private click;
+    private points;
+    private marks;
+}
+
+
+export {normalize} from 'intact-vue-next';

package/components/slider/index.js

@@ -0,0 +1,86 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import { Component } from 'intact-vue-next';
+import template from './index.vdt';
+import { useStep } from '../spinner/useStep';
+import { useValue } from './useValue';
+import { useDraggable } from './useDraggable';
+import { useStyles } from './useStyles';
+import { useKeyboard } from './useKeyboard';
+import { useClick } from './useClick';
+import { usePoints } from './usePoints';
+import { useMarks } from './useMarks';
+import { useTooltip } from './useTooltip';
+var typeDefs = {
+  max: Number,
+  min: Number,
+  value: [Number, Array],
+  range: Boolean,
+  unit: String,
+  showEnd: Boolean,
+  showInput: Boolean,
+  step: [Number, Object, Function],
+  points: [Array, Boolean],
+  marks: Object,
+  disabled: Boolean,
+  showTooltip: Boolean,
+  always: Boolean,
+  animate: Boolean,
+  tooltipProps: Object,
+  spinnerProps: Object,
+  forceStep: Boolean
+};
+var defaultStep = 1;
+
+var defaults = function defaults() {
+  return {
+    max: 100,
+    min: 0,
+    value: 0,
+    unit: '',
+    showEnd: true,
+    showInput: true,
+    step: defaultStep,
+    animate: true,
+    forceStep: true
+  };
+};
+
+var events = {
+  change: true
+};
+export var Slider = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(Slider, _Component);
+
+  function Slider() {
+    var _context;
+
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _Component.call.apply(_Component, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
+    _this.step = useStep(defaultStep);
+    _this.value = useValue(_this.step, function () {
+      return _this.draggable.dragging.value;
+    });
+    _this.tooltip = useTooltip(_this.value.showValue);
+    _this.draggable = useDraggable(_this.value.showValue, _this.value.fixValue, _this.value.triggerChangeEvent, _this.tooltip.show);
+    _this.styles = useStyles(_this.value.showValue);
+    _this.keyboard = useKeyboard(_this.step, _this.draggable.getNewValue, _this.value.fixValue, _this.draggable.isFirst, _this.draggable.dragging, _this.value.triggerChangeEvent);
+    _this.click = useClick(_this.draggable.getSlidingValue, _this.value.fixValue, _this.value.showValue, _this.value.setValue);
+    _this.points = usePoints(_this.value.showValue, _this.step);
+    _this.marks = useMarks();
+    return _this;
+  }
+
+  return Slider;
+}(Component);
+Slider.template = template;
+Slider.typeDefs = typeDefs;
+Slider.defaults = defaults;
+Slider.events = events;
+
+export {normalize} from 'intact-vue-next';

package/components/slider/index.spec.d.ts

@@ -0,0 +1,4 @@
+export {};
+
+
+export {normalize} from 'intact-vue-next';