265 lines
8.4 KiB
JavaScript
265 lines
8.4 KiB
JavaScript
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name2 in all)
|
|
__defProp(target, name2, { get: all[name2], 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var stdin_exports = {};
|
|
__export(stdin_exports, {
|
|
default: () => stdin_default,
|
|
numberKeyboardProps: () => numberKeyboardProps
|
|
});
|
|
module.exports = __toCommonJS(stdin_exports);
|
|
var import_vue = require("vue");
|
|
var import_utils = require("../utils");
|
|
var import_use = require("@vant/use");
|
|
var import_NumberKeyboardKey = __toESM(require("./NumberKeyboardKey"));
|
|
const [name, bem] = (0, import_utils.createNamespace)("number-keyboard");
|
|
const numberKeyboardProps = {
|
|
show: Boolean,
|
|
title: String,
|
|
theme: (0, import_utils.makeStringProp)("default"),
|
|
zIndex: import_utils.numericProp,
|
|
teleport: [String, Object],
|
|
maxlength: (0, import_utils.makeNumericProp)(Infinity),
|
|
modelValue: (0, import_utils.makeStringProp)(""),
|
|
transition: import_utils.truthProp,
|
|
blurOnClose: import_utils.truthProp,
|
|
showDeleteKey: import_utils.truthProp,
|
|
randomKeyOrder: Boolean,
|
|
closeButtonText: String,
|
|
deleteButtonText: String,
|
|
closeButtonLoading: Boolean,
|
|
hideOnClickOutside: import_utils.truthProp,
|
|
safeAreaInsetBottom: import_utils.truthProp,
|
|
extraKey: {
|
|
type: [String, Array],
|
|
default: ""
|
|
}
|
|
};
|
|
function shuffle(array) {
|
|
for (let i = array.length - 1; i > 0; i--) {
|
|
const j = Math.floor(Math.random() * (i + 1));
|
|
const temp = array[i];
|
|
array[i] = array[j];
|
|
array[j] = temp;
|
|
}
|
|
return array;
|
|
}
|
|
var stdin_default = (0, import_vue.defineComponent)({
|
|
name,
|
|
inheritAttrs: false,
|
|
props: numberKeyboardProps,
|
|
emits: ["show", "hide", "blur", "input", "close", "delete", "update:modelValue"],
|
|
setup(props, {
|
|
emit,
|
|
slots,
|
|
attrs
|
|
}) {
|
|
const root = (0, import_vue.ref)();
|
|
const genBasicKeys = () => {
|
|
const keys2 = Array(9).fill("").map((_, i) => ({
|
|
text: i + 1
|
|
}));
|
|
if (props.randomKeyOrder) {
|
|
shuffle(keys2);
|
|
}
|
|
return keys2;
|
|
};
|
|
const genDefaultKeys = () => [...genBasicKeys(), {
|
|
text: props.extraKey,
|
|
type: "extra"
|
|
}, {
|
|
text: 0
|
|
}, {
|
|
text: props.showDeleteKey ? props.deleteButtonText : "",
|
|
type: props.showDeleteKey ? "delete" : ""
|
|
}];
|
|
const genCustomKeys = () => {
|
|
const keys2 = genBasicKeys();
|
|
const {
|
|
extraKey
|
|
} = props;
|
|
const extraKeys = Array.isArray(extraKey) ? extraKey : [extraKey];
|
|
if (extraKeys.length === 0) {
|
|
keys2.push({
|
|
text: 0,
|
|
wider: true
|
|
});
|
|
} else if (extraKeys.length === 1) {
|
|
keys2.push({
|
|
text: 0,
|
|
wider: true
|
|
}, {
|
|
text: extraKeys[0],
|
|
type: "extra"
|
|
});
|
|
} else if (extraKeys.length === 2) {
|
|
keys2.push({
|
|
text: extraKeys[0],
|
|
type: "extra"
|
|
}, {
|
|
text: 0
|
|
}, {
|
|
text: extraKeys[1],
|
|
type: "extra"
|
|
});
|
|
}
|
|
return keys2;
|
|
};
|
|
const keys = (0, import_vue.computed)(() => props.theme === "custom" ? genCustomKeys() : genDefaultKeys());
|
|
const onBlur = () => {
|
|
if (props.show) {
|
|
emit("blur");
|
|
}
|
|
};
|
|
const onClose = () => {
|
|
emit("close");
|
|
if (props.blurOnClose) {
|
|
onBlur();
|
|
}
|
|
};
|
|
const onAnimationEnd = () => emit(props.show ? "show" : "hide");
|
|
const onPress = (text, type) => {
|
|
if (text === "") {
|
|
if (type === "extra") {
|
|
onBlur();
|
|
}
|
|
return;
|
|
}
|
|
const value = props.modelValue;
|
|
if (type === "delete") {
|
|
emit("delete");
|
|
emit("update:modelValue", value.slice(0, value.length - 1));
|
|
} else if (type === "close") {
|
|
onClose();
|
|
} else if (value.length < +props.maxlength) {
|
|
emit("input", text);
|
|
emit("update:modelValue", value + text);
|
|
}
|
|
};
|
|
const renderTitle = () => {
|
|
const {
|
|
title,
|
|
theme,
|
|
closeButtonText
|
|
} = props;
|
|
const leftSlot = slots["title-left"];
|
|
const showClose = closeButtonText && theme === "default";
|
|
const showTitle = title || showClose || leftSlot;
|
|
if (!showTitle) {
|
|
return;
|
|
}
|
|
return (0, import_vue.createVNode)("div", {
|
|
"class": bem("header")
|
|
}, [leftSlot && (0, import_vue.createVNode)("span", {
|
|
"class": bem("title-left")
|
|
}, [leftSlot()]), title && (0, import_vue.createVNode)("h2", {
|
|
"class": bem("title")
|
|
}, [title]), showClose && (0, import_vue.createVNode)("button", {
|
|
"type": "button",
|
|
"class": [bem("close"), import_utils.HAPTICS_FEEDBACK],
|
|
"onClick": onClose
|
|
}, [closeButtonText])]);
|
|
};
|
|
const renderKeys = () => keys.value.map((key) => {
|
|
const keySlots = {};
|
|
if (key.type === "delete") {
|
|
keySlots.default = slots.delete;
|
|
}
|
|
if (key.type === "extra") {
|
|
keySlots.default = slots["extra-key"];
|
|
}
|
|
return (0, import_vue.createVNode)(import_NumberKeyboardKey.default, {
|
|
"key": key.text,
|
|
"text": key.text,
|
|
"type": key.type,
|
|
"wider": key.wider,
|
|
"color": key.color,
|
|
"onPress": onPress
|
|
}, keySlots);
|
|
});
|
|
const renderSidebar = () => {
|
|
if (props.theme === "custom") {
|
|
return (0, import_vue.createVNode)("div", {
|
|
"class": bem("sidebar")
|
|
}, [props.showDeleteKey && (0, import_vue.createVNode)(import_NumberKeyboardKey.default, {
|
|
"large": true,
|
|
"text": props.deleteButtonText,
|
|
"type": "delete",
|
|
"onPress": onPress
|
|
}, {
|
|
default: slots.delete
|
|
}), (0, import_vue.createVNode)(import_NumberKeyboardKey.default, {
|
|
"large": true,
|
|
"text": props.closeButtonText,
|
|
"type": "close",
|
|
"color": "blue",
|
|
"loading": props.closeButtonLoading,
|
|
"onPress": onPress
|
|
}, null)]);
|
|
}
|
|
};
|
|
(0, import_vue.watch)(() => props.show, (value) => {
|
|
if (!props.transition) {
|
|
emit(value ? "show" : "hide");
|
|
}
|
|
});
|
|
if (props.hideOnClickOutside) {
|
|
(0, import_use.useClickAway)(root, onBlur, {
|
|
eventName: "touchstart"
|
|
});
|
|
}
|
|
return () => {
|
|
const Title = renderTitle();
|
|
const Content = (0, import_vue.createVNode)(import_vue.Transition, {
|
|
"name": props.transition ? "van-slide-up" : ""
|
|
}, {
|
|
default: () => [(0, import_vue.withDirectives)((0, import_vue.createVNode)("div", (0, import_vue.mergeProps)({
|
|
"ref": root,
|
|
"style": (0, import_utils.getZIndexStyle)(props.zIndex),
|
|
"class": bem({
|
|
unfit: !props.safeAreaInsetBottom,
|
|
"with-title": !!Title
|
|
}),
|
|
"onAnimationend": onAnimationEnd,
|
|
"onTouchstartPassive": import_utils.stopPropagation
|
|
}, attrs), [Title, (0, import_vue.createVNode)("div", {
|
|
"class": bem("body")
|
|
}, [(0, import_vue.createVNode)("div", {
|
|
"class": bem("keys")
|
|
}, [renderKeys()]), renderSidebar()])]), [[import_vue.vShow, props.show]])]
|
|
});
|
|
if (props.teleport) {
|
|
return (0, import_vue.createVNode)(import_vue.Teleport, {
|
|
"to": props.teleport
|
|
}, {
|
|
default: () => [Content]
|
|
});
|
|
}
|
|
return Content;
|
|
};
|
|
}
|
|
});
|