${labelOpt.content}
`;
marker.setLabel({
content,
direction: "bottom-right"
});
} else {
const className = updateMarkerLabelStyle(labelStyle);
marker.setLabel({
text: labelOpt.content,
color: labelStyle.color,
fontSize: labelStyle.fontSize,
className
});
}
}
}
const calloutOpt = option.callout || {};
let callout = marker.callout;
let calloutStyle;
if (calloutOpt.content || title) {
if (getIsAMap() && calloutOpt.content) {
calloutOpt.content = calloutOpt.content.replaceAll("\n", "
");
}
const boxShadow = "0px 0px 3px 1px rgba(0,0,0,0.5)";
let offsetY = -imgHeight / 2;
if (option.width || option.height) {
offsetY += 14 - imgHeight / 2;
}
calloutStyle = calloutOpt.content ? {
position,
map,
top,
// handle AMap callout offset
offsetY,
content: calloutOpt.content,
color: calloutOpt.color,
fontSize: calloutOpt.fontSize,
borderRadius: calloutOpt.borderRadius,
bgColor: calloutOpt.bgColor,
padding: calloutOpt.padding,
boxShadow: calloutOpt.boxShadow || boxShadow,
display: calloutOpt.display
} : {
position,
map,
top,
// handle AMap callout offset
offsetY,
content: title,
boxShadow
};
if (callout) {
callout.setOption(calloutStyle);
} else {
if (getIsAMap()) {
const callback = (id2) => {
if (id2 !== "") {
trigger("callouttap", {}, {
markerId: Number(id2)
});
}
};
callout = marker.callout = new maps.Callout(calloutStyle, callback);
} else {
callout = marker.callout = new maps.Callout(calloutStyle);
callout.div.onclick = function($event) {
if (id !== "") {
trigger("callouttap", $event, {
markerId: Number(id)
});
}
$event.stopPropagation();
$event.preventDefault();
};
if (getMapInfo().type === MapType.GOOGLE) {
callout.div.ontouchstart = function($event) {
$event.stopPropagation();
};
callout.div.onpointerdown = function($event) {
$event.stopPropagation();
};
}
}
}
} else {
if (callout) {
removeMarkerCallout(callout);
delete marker.callout;
}
}
};
if (option.iconPath) {
img.src = getRealPath(option.iconPath);
} else {
console.error("Marker.iconPath is required.");
}
}
function addMarker(props3) {
if (!getIsBMap()) {
marker = new maps.Marker({
map,
flat: true,
autoRotation: false
});
}
updateMarker(props3);
const MapsEvent = maps.event || maps.Event;
if (getIsBMap())
;
else {
MapsEvent.addListener(marker, "click", () => {
const callout = marker.callout;
if (callout && !callout.alwaysVisible) {
if (getIsAMap()) {
callout.visible = !callout.visible;
if (callout.visible) {
marker.callout.createAMapText();
} else {
marker.callout.removeAMapText();
}
} else {
callout.set("visible", !callout.visible);
if (callout.visible) {
const div = callout.div;
const parent = div.parentNode;
parent.removeChild(div);
parent.appendChild(div);
}
}
}
if (id) {
trigger("markertap", {}, {
markerId: Number(id),
latitude: props3.latitude,
longitude: props3.longitude
});
}
});
}
}
addMarker(props2);
vue.watch(props2, updateMarker);
});
if (id) {
const addMapChidlContext = vue.inject("addMapChidlContext");
vue.inject("removeMapChidlContext");
const context = {
id,
translate(data) {
onMapReady((map, maps, trigger) => {
const destination = data.destination;
const duration = data.duration;
const autoRotate = !!data.autoRotate;
let rotate = Number(data.rotate) || 0;
let rotation = 0;
if ("getRotation" in marker) {
rotation = marker.getRotation();
}
const a = marker.getPosition();
const b = new maps.LatLng(destination.latitude, destination.longitude);
const distance = maps.geometry.spherical.computeDistanceBetween(a, b) / 1e3;
const time = (typeof duration === "number" ? duration : 1e3) / (1e3 * 60 * 60);
const speed = distance / time;
const MapsEvent = maps.event || maps.Event;
const movingEvent = MapsEvent.addListener(marker, "moving", (e2) => {
const latLng = e2.latLng;
const label = marker.label;
if (label) {
label.setPosition(latLng);
}
const callout = marker.callout;
if (callout) {
callout.setPosition(latLng);
}
});
const event = MapsEvent.addListener(marker, "moveend", () => {
event.remove();
movingEvent.remove();
marker.lastPosition = a;
marker.setPosition(b);
const label = marker.label;
if (label) {
label.setPosition(b);
}
const callout = marker.callout;
if (callout) {
callout.setPosition(b);
}
const cb = data.animationEnd;
if (shared.isFunction(cb)) {
cb();
}
});
let lastRtate = 0;
if (autoRotate) {
if (marker.lastPosition) {
lastRtate = maps.geometry.spherical.computeHeading(marker.lastPosition, a);
}
rotate = maps.geometry.spherical.computeHeading(a, b) - lastRtate;
}
if ("setRotation" in marker) {
marker.setRotation(rotation + rotate);
}
if ("moveTo" in marker) {
marker.moveTo(b, speed);
} else {
marker.setPosition(b);
MapsEvent.trigger(marker, "moveend", {});
}
});
}
};
addMapChidlContext(context);
}
return () => {
return null;
};
}
});
function hexToRgba(hex) {
if (!hex) {
return {
r: 0,
g: 0,
b: 0,
a: 0
};
}
let tmpHex = hex.slice(1);
const tmpHexLen = tmpHex.length;
if (![3, 4, 6, 8].includes(tmpHexLen)) {
return {
r: 0,
g: 0,
b: 0,
a: 0
};
}
if (tmpHexLen === 3 || tmpHexLen === 4) {
tmpHex = tmpHex.replace(/(\w{1})/g, "$1$1");
}
let [sr, sg, sb, sa] = tmpHex.match(/(\w{2})/g);
const r = parseInt(sr, 16), g2 = parseInt(sg, 16), b = parseInt(sb, 16);
if (!sa) {
return { r, g: g2, b, a: 1 };
}
return {
r,
g: g2,
b,
a: (`0x100${sa}` - 65536) / 255
};
}
const props$6 = {
points: {
type: Array,
require: true
},
color: {
type: String,
default: "#000000"
},
width: {
type: [Number, String],
default: ""
},
dottedLine: {
type: [Boolean, String],
default: false
},
arrowLine: {
type: [Boolean, String],
default: false
},
arrowIconPath: {
type: String,
default: ""
},
borderColor: {
type: String,
default: "#000000"
},
borderWidth: {
type: [Number, String],
default: ""
},
colorList: {
type: Array,
default() {
return [];
}
},
level: {
type: String,
default: ""
}
};
const MapPolyline = /* @__PURE__ */ defineSystemComponent({
name: "MapPolyline",
props: props$6,
setup(props2) {
const onMapReady = vue.inject("onMapReady");
let polyline;
let polylineBorder;
function removePolyline() {
if (polyline) {
polyline.setMap(null);
}
if (polylineBorder) {
polylineBorder.setMap(null);
}
}
onMapReady((map, maps) => {
function updatePolyline(option) {
removePolyline();
addPolyline(option);
}
function addPolyline(option) {
const path = [];
option.points.forEach((point) => {
let pointPosition;
if (getIsAMap()) {
pointPosition = [point.longitude, point.latitude];
} else if (getIsBMap()) {
pointPosition = new maps.Point(point.longitude, point.latitude);
} else {
pointPosition = new maps.LatLng(point.latitude, point.longitude);
}
path.push(pointPosition);
});
const strokeWeight = Number(option.width) || 1;
const {
r: sr,
g: sg,
b: sb,
a: sa
} = hexToRgba(option.color);
const {
r: br,
g: bg,
b: bb,
a: ba
} = hexToRgba(option.borderColor);
const polylineOptions = {
map,
clickable: false,
path,
strokeWeight,
strokeColor: option.color || void 0,
strokeDashStyle: option.dottedLine ? "dash" : "solid"
};
const borderWidth = Number(option.borderWidth) || 0;
const polylineBorderOptions = {
map,
clickable: false,
path,
strokeWeight: strokeWeight + borderWidth * 2,
strokeColor: option.borderColor || void 0,
strokeDashStyle: option.dottedLine ? "dash" : "solid"
};
if ("Color" in maps) {
polylineOptions.strokeColor = new maps.Color(sr, sg, sb, sa);
polylineBorderOptions.strokeColor = new maps.Color(br, bg, bb, ba);
} else {
polylineOptions.strokeColor = `rgb(${sr}, ${sg}, ${sb})`;
polylineOptions.strokeOpacity = sa;
polylineBorderOptions.strokeColor = `rgb(${br}, ${bg}, ${bb})`;
polylineBorderOptions.strokeOpacity = ba;
}
if (borderWidth) {
polylineBorder = new maps.Polyline(polylineBorderOptions);
}
if (getIsBMap()) {
polyline = new maps.Polyline(polylineOptions.path, polylineOptions);
map.addOverlay(polyline);
} else {
polyline = new maps.Polyline(polylineOptions);
}
}
addPolyline(props2);
vue.watch(props2, updatePolyline);
});
return () => {
return null;
};
}
});
const props$5 = {
latitude: {
type: [Number, String],
require: true
},
longitude: {
type: [Number, String],
require: true
},
color: {
type: String,
default: "#000000"
},
fillColor: {
type: String,
default: "#00000000"
},
radius: {
type: [Number, String],
require: true
},
strokeWidth: {
type: [Number, String],
default: ""
},
level: {
type: String,
default: ""
}
};
const MapCircle = /* @__PURE__ */ defineSystemComponent({
name: "MapCircle",
props: props$5,
setup(props2) {
const onMapReady = vue.inject("onMapReady");
let circle;
function removeCircle() {
if (circle) {
circle.setMap(null);
}
}
onMapReady((map, maps) => {
function updateCircle(option) {
removeCircle();
addCircle(option);
}
function addCircle(option) {
const center = getIsAMap() || getIsBMap() ? [option.longitude, option.latitude] : new maps.LatLng(option.latitude, option.longitude);
const circleOptions = {
map,
center,
clickable: false,
radius: option.radius,
strokeWeight: Number(option.strokeWidth) || 1,
strokeDashStyle: "solid"
};
if (getIsBMap()) {
circleOptions.strokeColor = option.color;
circleOptions.fillColor = option.fillColor || "#000";
circleOptions.fillOpacity = 1;
} else {
const {
r: fr,
g: fg,
b: fb,
a: fa
} = hexToRgba(option.fillColor);
const {
r: sr,
g: sg,
b: sb,
a: sa
} = hexToRgba(option.color);
if ("Color" in maps) {
circleOptions.fillColor = new maps.Color(fr, fg, fb, fa);
circleOptions.strokeColor = new maps.Color(sr, sg, sb, sa);
} else {
circleOptions.fillColor = `rgb(${fr}, ${fg}, ${fb})`;
circleOptions.fillOpacity = fa;
circleOptions.strokeColor = `rgb(${sr}, ${sg}, ${sb})`;
circleOptions.strokeOpacity = sa;
}
}
if (getIsBMap()) {
let pt = new maps.Point(
// @ts-ignore
circleOptions.center[0],
// @ts-ignore
circleOptions.center[1]
);
circle = new maps.Circle(pt, circleOptions.radius, circleOptions);
map.addOverlay(circle);
} else {
circle = new maps.Circle(circleOptions);
if (getIsAMap()) {
map.add(circle);
}
}
}
addCircle(props2);
vue.watch(props2, updateCircle);
});
return () => {
return null;
};
}
});
const props$4 = {
id: {
type: [Number, String],
default: ""
},
position: {
type: Object,
required: true
},
iconPath: {
type: String,
required: true
},
clickable: {
type: [Boolean, String],
default: ""
},
trigger: {
type: Function,
required: true
}
};
const MapControl = /* @__PURE__ */ defineSystemComponent({
name: "MapControl",
props: props$4,
setup(props2) {
const imgPath = vue.computed(() => getRealPath(props2.iconPath));
const positionStyle = vue.computed(() => {
let positionStyle2 = `top:${props2.position.top || 0}px;left:${props2.position.left || 0}px;`;
if (props2.position.width) {
positionStyle2 += `width:${props2.position.width}px;`;
}
if (props2.position.height) {
positionStyle2 += `height:${props2.position.height}px;`;
}
return positionStyle2;
});
const handleClick = ($event) => {
if (props2.clickable) {
props2.trigger("controltap", $event, {
controlId: props2.id
});
}
};
return () => {
return vue.createVNode("div", {
"class": "uni-map-control"
}, [vue.createVNode("img", {
"src": imgPath.value,
"style": positionStyle.value,
"class": "uni-map-control-icon",
"onClick": handleClick
}, null, 12, ["src", "onClick"])]);
};
}
});
const CONTEXT_ID = "MAP_LOCATION";
const MapLocation = /* @__PURE__ */ defineSystemComponent({
name: "MapLocation",
setup() {
const state = vue.reactive({
latitude: 0,
longitude: 0,
rotate: 0
});
return () => {
return state.latitude ? vue.createVNode(MapMarker, vue.mergeProps({
"anchor": {
x: 0.5,
y: 0.5
},
"width": "44",
"height": "44",
"iconPath": ICON_PATH_ORIGIN
}, state), null, 16, ["iconPath"]) : null;
};
}
});
const props$3 = {
// 边框虚线，腾讯地图支持，google 高德 地图不支持，默认值为[0, 0] 为实线，非 [0, 0] 为虚线，H5 端无法像微信小程序一样控制虚线的间隔像素大小
dashArray: {
type: Array,
default: () => [0, 0]
},
// 经纬度数组，[{latitude: 0, longitude: 0}]
points: {
type: Array,
required: true
},
// 描边的宽度
strokeWidth: {
type: Number,
default: 1
},
// 描边的颜色，十六进制
strokeColor: {
type: String,
default: "#000000"
},
// 填充颜色，十六进制
fillColor: {
type: String,
default: "#00000000"
},
// 设置多边形 Z 轴数值
zIndex: {
type: Number,
default: 0
}
};
const MapPolygon = /* @__PURE__ */ defineSystemComponent({
name: "MapPolygon",
props: props$3,
setup(props2) {
let polygonIns;
const onMapReady = vue.inject("onMapReady");
onMapReady((map, maps, trigger) => {
function drawPolygon() {
const {
points,
strokeWidth,
strokeColor,
dashArray,
fillColor,
zIndex
} = props2;
const path = points.map((item) => {
const {
latitude,
longitude
} = item;
if (getIsAMap()) {
return [longitude, latitude];
} else if (getIsBMap()) {
return new maps.Point(longitude, latitude);
} else {
return new maps.LatLng(latitude, longitude);
}
});
const {
r: fcR,
g: fcG,
b: fcB,
a: fcA
} = hexToRgba(fillColor);
const {
r: scR,
g: scG,
b: scB,
a: scA
} = hexToRgba(strokeColor);
const polygonOptions = {
//多边形是否可点击。
clickable: true,
//鼠标在多边形内的光标样式。
cursor: "crosshair",
//多边形是否可编辑。
editable: false,
// 地图实例，即要显示多边形的地图
// @ts-ignore
map,
// 区域填充色
fillColor: "",
//多边形的路径，以经纬度坐标数组构成。
path,
// 区域边框
strokeColor: "",
//多边形的边框样式。实线是solid，虚线是dash。
strokeDashStyle: dashArray.some((item) => item > 0) ? "dash" : "solid",
//多边形的边框线宽。
strokeWeight: strokeWidth,
//多边形是否可见。
visible: true,
//多边形的zIndex值。
zIndex
};
if (maps.Color) {
polygonOptions.fillColor = new maps.Color(fcR, fcG, fcB, fcA);
polygonOptions.strokeColor = new maps.Color(scR, scG, scB, scA);
} else {
polygonOptions.fillColor = `rgb(${fcR}, ${fcG}, ${fcB})`;
polygonOptions.fillOpacity = fcA;
polygonOptions.strokeColor = `rgb(${scR}, ${scG}, ${scB})`;
polygonOptions.strokeOpacity = scA;
}
if (polygonIns) {
polygonIns.setOptions(polygonOptions);
return;
}
if (getIsBMap()) {
polygonIns = new maps.Polygon(polygonOptions.path, polygonOptions);
map.addOverlay(polygonIns);
} else {
polygonIns = new maps.Polygon(polygonOptions);
}
}
drawPolygon();
vue.watch(props2, drawPolygon);
});
return () => null;
}
});
const props$2 = {
id: {
type: String,
default: ""
},
latitude: {
type: [String, Number],
default: 0
},
longitude: {
type: [String, Number],
default: 0
},
scale: {
type: [String, Number],
default: 16
},
markers: {
type: Array,
default() {
return [];
}
},
includePoints: {
type: Array,
default() {
return [];
}
},
polyline: {
type: Array,
default() {
return [];
}
},
circles: {
type: Array,
default() {
return [];
}
},
controls: {
type: Array,
default() {
return [];
}
},
showLocation: {
type: [Boolean, String],
default: false
},
libraries: {
type: Array,
default() {
return [];
}
},
polygons: {
type: Array,
default: () => []
}
};
function getPoints(points) {
const newPoints = [];
if (shared.isArray(points)) {
points.forEach((point) => {
if (point && point.latitude && point.longitude) {
newPoints.push({
latitude: point.latitude,
longitude: point.longitude
});
}
});
}
return newPoints;
}
function getAMapPosition(maps, latitude, longitude) {
return new maps.LngLat(longitude, latitude);
}
function getBMapPosition(maps, latitude, longitude) {
return new maps.Point(longitude, latitude);
}
function getGoogleOrQQMapPosition(maps, latitude, longitude) {
return new maps.LatLng(latitude, longitude);
}
function getMapPosition(maps, latitude, longitude) {
if (getIsBMap()) {
return getBMapPosition(maps, latitude, longitude);
} else if (getIsAMap()) {
return getAMapPosition(maps, latitude, longitude);
} else {
return getGoogleOrQQMapPosition(maps, latitude, longitude);
}
}
function getLat(latLng) {
if ("getLat" in latLng) {
return latLng.getLat();
} else {
if (getIsBMap()) {
return latLng.lat;
}
return latLng.lat();
}
}
function getLng(latLng) {
if ("getLng" in latLng) {
return latLng.getLng();
} else {
if (getIsBMap()) {
return latLng.lng;
}
return latLng.lng();
}
}
function useMap(props2, rootRef, emit2) {
const trigger = useCustomEvent(rootRef, emit2);
const mapRef = vue.ref(null);
let maps;
let map;
const state = vue.reactive({
latitude: Number(props2.latitude),
longitude: Number(props2.longitude),
includePoints: getPoints(props2.includePoints)
});
function onMapReady(callback) {
}
let isBoundsReady;
function onBoundsReady(callback) {
}
const contexts = {};
function addMapChidlContext(context) {
contexts[context.id] = context;
}
function removeMapChidlContext(context) {
delete contexts[context.id];
}
vue.watch([() => props2.latitude, () => props2.longitude], ([latitudeVlaue, longitudeVlaue]) => {
const latitude = Number(latitudeVlaue);
const longitude = Number(longitudeVlaue);
if (latitude !== state.latitude || longitude !== state.longitude) {
state.latitude = latitude;
state.longitude = longitude;
}
});
vue.watch(() => props2.includePoints, (points) => {
state.includePoints = getPoints(points);
}, {
deep: true
});
function updateBounds() {
if (getIsAMap()) {
const points = [];
state.includePoints.forEach((point) => {
points.push([point.longitude, point.latitude]);
});
const bounds = new maps.Bounds(...points);
map.setBounds(bounds);
} else if (getIsBMap())
;
else {
const bounds = new maps.LatLngBounds();
state.includePoints.forEach(({
latitude,
longitude
}) => {
const latLng = new maps.LatLng(latitude, longitude);
bounds.extend(latLng);
});
map.fitBounds(bounds);
}
}
try {
const id = useContextInfo();
useSubscribe((type, data = {}) => {
switch (type) {
case "getCenterLocation":
onMapReady(() => {
const center = map.getCenter();
uniShared.callOptions(data, {
latitude: getLat(center),
longitude: getLng(center),
errMsg: `${type}:ok`
});
});
break;
case "moveToLocation":
{
let latitude = Number(data.latitude);
let longitude = Number(data.longitude);
if (!latitude || !longitude) {
const context = contexts[CONTEXT_ID];
if (context) {
latitude = context.state.latitude;
longitude = context.state.longitude;
}
}
if (latitude && longitude) {
state.latitude = latitude;
state.longitude = longitude;
if (map)
;
onMapReady(() => {
uniShared.callOptions(data, `${type}:ok`);
});
} else {
uniShared.callOptions(data, `${type}:fail`);
}
}
break;
case "translateMarker":
onMapReady(() => {
const context = contexts[data.markerId];
if (context) {
try {
context.translate(data);
} catch (error) {
uniShared.callOptions(data, `${type}:fail ${error.message}`);
}
uniShared.callOptions(data, `${type}:ok`);
} else {
uniShared.callOptions(data, `${type}:fail not found`);
}
});
break;
case "includePoints":
state.includePoints = getPoints(data.includePoints);
if (isBoundsReady || getIsAMap()) {
updateBounds();
}
onBoundsReady(() => {
uniShared.callOptions(data, `${type}:ok`);
});
break;
case "getRegion":
onBoundsReady(() => {
const latLngBounds = map.getBounds();
const southwest = latLngBounds.getSouthWest();
const northeast = latLngBounds.getNorthEast();
uniShared.callOptions(data, {
southwest: {
latitude: getLat(southwest),
longitude: getLng(southwest)
},
northeast: {
latitude: getLat(northeast),
longitude: getLng(northeast)
},
errMsg: `${type}:ok`
});
});
break;
case "getScale":
onMapReady(() => {
uniShared.callOptions(data, {
scale: map.getZoom(),
errMsg: `${type}:ok`
});
});
break;
}
}, id, true);
} catch (error) {
}
vue.provide("onMapReady", onMapReady);
vue.provide("addMapChidlContext", addMapChidlContext);
vue.provide("removeMapChidlContext", removeMapChidlContext);
return {
state,
mapRef,
trigger
};
}
const index$a = /* @__PURE__ */ defineBuiltInComponent({
name: "Map",
props: props$2,
emits: ["markertap", "labeltap", "callouttap", "controltap", "regionchange", "tap", "click", "updated", "update:scale", "update:latitude", "update:longitude"],
setup(props2, {
emit: emit2,
slots
}) {
const rootRef = vue.ref(null);
const {
mapRef,
trigger
} = useMap(props2, rootRef, emit2);
return () => {
return vue.createVNode("uni-map", {
"ref": rootRef,
"id": props2.id
}, [vue.createVNode("div", {
"ref": mapRef,
"style": "width: 100%; height: 100%; position: relative; overflow: hidden"
}, null, 512), props2.markers.map((item) => vue.createVNode(MapMarker, vue.mergeProps({
"key": item.id
}, item), null, 16)), props2.polyline.map((item) => vue.createVNode(MapPolyline, item, null, 16)), props2.circles.map((item) => vue.createVNode(MapCircle, item, null, 16)), props2.controls.map((item) => vue.createVNode(MapControl, vue.mergeProps(item, {
"trigger": trigger
}), null, 16, ["trigger"])), props2.showLocation && vue.createVNode(MapLocation, null, null), props2.polygons.map((item) => vue.createVNode(MapPolygon, item, null, 16)), vue.createVNode("div", {
"style": "position: absolute;top: 0;width: 100%;height: 100%;overflow: hidden;pointer-events: none;"
}, [slots.default && slots.default()])], 8, ["id"]);
};
}
});
const props$1 = {
scrollTop: {
type: [String, Number],
default: 0
}
};
const index$9 = /* @__PURE__ */ defineBuiltInComponent({
name: "CoverView",
compatConfig: {
MODE: 3
},
props: props$1,
setup(props2, {
slots
}) {
const content = vue.ref(null);
vue.watch(() => props2.scrollTop, (val) => {
setScrollTop(val);
});
function setScrollTop(val) {
let _content = content.value;
if (getComputedStyle(_content).overflowY === "scroll") {
_content.scrollTop = _upx2pxNum(val);
}
}
function _upx2pxNum(val) {
let _val = String(val);
if (/\d+[ur]px$/i.test(_val)) {
_val.replace(/\d+[ur]px$/i, (text) => {
return String(uni.upx2px(parseFloat(text)));
});
}
return parseFloat(_val) || 0;
}
return () => {
return vue.createVNode("uni-cover-view", {
"scroll-top": props2.scrollTop
}, [vue.createVNode("div", {
"ref": content,
"class": "uni-cover-view"
}, [slots.default && slots.default()], 512)], 8, ["scroll-top"]);
};
}
});
const index$8 = /* @__PURE__ */ defineBuiltInComponent({
name: "CoverImage",
compatConfig: {
MODE: 3
},
props: {
src: {
type: String,
default: ""
}
},
emits: ["load", "error"],
setup(props2, {
emit: emit2
}) {
const root = vue.ref(null);
const trigger = useCustomEvent(root, emit2);
function load($event) {
trigger("load", $event);
}
function error($event) {
trigger("error", $event);
}
return () => {
const {
src
} = props2;
return vue.createVNode("uni-cover-image", {
"ref": root,
"src": src
}, [vue.createVNode("div", {
"class": "uni-cover-image"
}, [src ? vue.createVNode("img", {
"src": getRealPath(src),
"onLoad": load,
"onError": error
}, null, 40, ["src", "onLoad", "onError"]) : null])], 8, ["src"]);
};
}
});
function usePopupStyle(props2) {
const popupWidth = vue.ref(0);
const popupHeight = vue.ref(0);
const isDesktop = vue.computed(
() => popupWidth.value >= 500 && popupHeight.value >= 500
);
const popupStyle = vue.computed(() => {
const style = {
content: {
transform: "",
left: "",
top: "",
bottom: ""
},
triangle: {
left: "",
top: "",
bottom: "",
"border-width": "",
"border-color": ""
}
};
const contentStyle = style.content;
const triangleStyle = style.triangle;
const popover = props2.popover;
function getNumber(value) {
return Number(value) || 0;
}
if (isDesktop.value && popover) {
shared.extend(triangleStyle, {
position: "absolute",
width: "0",
height: "0",
"margin-left": "-6px",
"border-style": "solid"
});
const popoverLeft = getNumber(popover.left);
const popoverWidth = getNumber(popover.width);
const popoverTop = getNumber(popover.top);
const popoverHeight = getNumber(popover.height);
const center = popoverLeft + popoverWidth / 2;
contentStyle.transform = "none !important";
const contentLeft = Math.max(0, center - 300 / 2);
contentStyle.left = `${contentLeft}px`;
let triangleLeft = Math.max(12, center - contentLeft);
triangleLeft = Math.min(300 - 12, triangleLeft);
triangleStyle.left = `${triangleLeft}px`;
const vcl = popupHeight.value / 2;
if (popoverTop + popoverHeight - vcl > vcl - popoverTop) {
contentStyle.top = "auto";
contentStyle.bottom = `${popupHeight.value - popoverTop + 6}px`;
triangleStyle.bottom = "-6px";
triangleStyle["border-width"] = "6px 6px 0 6px";
triangleStyle["border-color"] = "#fcfcfd transparent transparent transparent";
} else {
contentStyle.top = `${popoverTop + popoverHeight + 6}px`;
triangleStyle.top = "-6px";
triangleStyle["border-width"] = "0 6px 6px 6px";
triangleStyle["border-color"] = "transparent transparent #fcfcfd transparent";
}
}
return style;
});
return {
isDesktop,
popupStyle
};
}
function useKeyboard() {
const key = vue.ref("");
const disable = vue.ref(false);
return {
key,
disable
};
}
function _isSlot(s) {
return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
}
function getDefaultStartValue(props2) {
if (props2.mode === mode.TIME) {
return "00:00";
}
if (props2.mode === mode.DATE) {
const year = (/* @__PURE__ */ new Date()).getFullYear() - 150;
switch (props2.fields) {
case fields.YEAR:
return year.toString();
case fields.MONTH:
return year + "-01";
default:
return year + "-01-01";
}
}
return "";
}
function getDefaultEndValue(props2) {
if (props2.mode === mode.TIME) {
return "23:59";
}
if (props2.mode === mode.DATE) {
const year = (/* @__PURE__ */ new Date()).getFullYear() + 150;
switch (props2.fields) {
case fields.YEAR:
return year.toString();
case fields.MONTH:
return year + "-12";
default:
return year + "-12-31";
}
}
return "";
}
function getDateValueArray(props2, state, valueStr, defaultValue) {
const splitStr = props2.mode === mode.DATE ? "-" : ":";
const array = props2.mode === mode.DATE ? state.dateArray : state.timeArray;
let max;
if (props2.mode === mode.TIME) {
max = 2;
} else {
switch (props2.fields) {
case fields.YEAR:
max = 1;
break;
case fields.MONTH:
max = 2;
break;
default:
max = 3;
break;
}
}
const inputArray = String(valueStr).split(splitStr);
let value = [];
for (let i = 0; i < max; i++) {
const val = inputArray[i];
value.push(array[i].indexOf(val));
}
if (value.indexOf(-1) >= 0) {
value = defaultValue ? getDateValueArray(props2, state, defaultValue) : value.map(() => 0);
}
return value;
}
const mode = {
SELECTOR: "selector",
MULTISELECTOR: "multiSelector",
TIME: "time",
DATE: "date"
// 暂不支持城市选择
// REGION: 'region'
};
const fields = {
YEAR: "year",
MONTH: "month",
DAY: "day"
};
const selectorType = {
PICKER: "picker",
SELECT: "select"
};
const props = {
name: {
type: String,
default: ""
},
range: {
type: Array,
default() {
return [];
}
},
rangeKey: {
type: String,
default: ""
},
value: {
type: [Number, String, Array],
default: 0
},
mode: {
type: String,
default: mode.SELECTOR,
validator(val) {
return Object.values(mode).includes(val);
}
},
fields: {
type: String,
default: ""
},
start: {
type: String,
default: (props2) => {
return getDefaultStartValue(props2);
}
},
end: {
type: String,
default: (props2) => {
return getDefaultEndValue(props2);
}
},
disabled: {
type: [Boolean, String],
default: false
},
selectorType: {
type: String,
default: ""
}
};
const index$7 = /* @__PURE__ */ defineBuiltInComponent({
name: "Picker",
compatConfig: {
MODE: 3
},
props,
emits: ["change", "cancel", "columnchange"],
setup(props2, {
emit: emit2,
slots
}) {
initI18nPickerMsgsOnce();
const {
t: t2
} = useI18n();
const rootRef = vue.ref(null);
const pickerRef = vue.ref(null);
const selectRef = vue.ref(null);
const inputRef = vue.ref(null);
const pickerRender = vue.ref(false);
const {
state,
rangeArray
} = usePickerState(props2);
const trigger = useCustomEvent(rootRef, emit2);
const {
system,
selectorTypeComputed,
_show,
_l10nColumn,
_l10nItem,
_input,
_fixInputPosition,
_pickerViewChange,
_cancel,
_change,
_resetFormData,
_getFormData,
_createTime,
_createDate,
_setValueSync
} = usePickerMethods(props2, state, trigger, rootRef, pickerRef, selectRef, inputRef);
usePickerWatch(state, _cancel, _change);
usePickerForm(_resetFormData, _getFormData);
_createTime();
_createDate();
_setValueSync();
const popup = usePopupStyle(state);
vue.watchEffect(() => {
state.isDesktop = popup.isDesktop.value;
state.popupStyle = popup.popupStyle.value;
});
return () => {
let _slot2;
const {
visible,
contentVisible,
valueArray,
popupStyle,
valueSync
} = state;
const {
rangeKey,
mode: mode2,
start,
end
} = props2;
const booleanAttrs = useBooleanAttr(props2, "disabled");
return vue.createVNode("uni-picker", vue.mergeProps({
"ref": rootRef
}, booleanAttrs, {
"onClick": withWebEvent(_show)
}), [pickerRender.value ? vue.createVNode("div", {
"ref": pickerRef,
"class": ["uni-picker-container", `uni-${mode2}-${selectorTypeComputed.value}`],
"onWheel": onEventPrevent,
"onTouchmove": onEventPrevent
}, [vue.createVNode(vue.Transition, {
"name": "uni-fade"
}, {
default: () => [vue.withDirectives(vue.createVNode("div", {
"class": "uni-mask uni-picker-mask",
"onClick": withWebEvent(_cancel),
"onMousemove": _fixInputPosition
}, null, 40, ["onClick", "onMousemove"]), [[vue.vShow, visible]])]
}), !system.value ? vue.createVNode("div", {
"class": [{
"uni-picker-toggle": visible
}, "uni-picker-custom"],
"style": popupStyle.content
}, [vue.createVNode("div", {
"class": "uni-picker-header",
"onClick": onEventStop
}, [vue.createVNode("div", {
"class": "uni-picker-action uni-picker-action-cancel",
"onClick": withWebEvent(_cancel)
}, [t2("uni.picker.cancel")], 8, ["onClick"]), vue.createVNode("div", {
"class": "uni-picker-action uni-picker-action-confirm",
"onClick": _change
}, [t2("uni.picker.done")], 8, ["onClick"])], 8, ["onClick"]), contentVisible ? vue.createVNode(PickerView, {
"value": _l10nColumn(valueArray),
"class": "uni-picker-content",
"onChange": _pickerViewChange
}, _isSlot(_slot2 = vue.renderList(_l10nColumn(rangeArray.value), (rangeItem, index0) => {
let _slot;
return vue.createVNode(PickerViewColumn, {
"key": index0
}, _isSlot(_slot = vue.renderList(rangeItem, (item, index2) => vue.createVNode("div", {
"key": index2,
"class": "uni-picker-item"
}, [typeof item === "object" ? item[rangeKey] || "" : _l10nItem(item, index0)]))) ? _slot : {
default: () => [_slot],
_: 1
});
})) ? _slot2 : {
default: () => [_slot2],
_: 1
}, 8, ["value", "onChange"]) : null, vue.createVNode("div", {
"ref": selectRef,
"class": "uni-picker-select",
"onWheel": onEventStop,
"onTouchmove": onEventStop
}, [vue.renderList(rangeArray.value[0], (item, index2) => vue.createVNode("div", {
"key": index2,
"class": ["uni-picker-item", {
selected: valueArray[0] === index2
}],
"onClick": () => {
valueArray[0] = index2;
_change();
}
}, [typeof item === "object" ? item[rangeKey] || "" : item], 10, ["onClick"]))], 40, ["onWheel", "onTouchmove"]), vue.createVNode("div", {
"style": popupStyle.triangle
}, null, 4)], 6) : null], 40, ["onWheel", "onTouchmove"]) : null, vue.createVNode("div", null, [slots.default && slots.default()]), system.value ? vue.createVNode("div", {
"class": "uni-picker-system",
"onMousemove": withWebEvent(_fixInputPosition)
}, [vue.createVNode("input", {
"class": ["uni-picker-system_input", system.value],
"ref": inputRef,
"value": valueSync,
"type": mode2,
"tabindex": "-1",
"min": start,
"max": end,
"onChange": ($event) => {
_input($event);
onEventStop($event);
}
}, null, 42, ["value", "type", "min", "max", "onChange"])], 40, ["onMousemove"]) : null], 16, ["onClick"]);
};
}
});
function usePickerState(props2) {
const state = vue.reactive({
valueSync: void 0,
visible: false,
contentVisible: false,
popover: null,
valueChangeSource: "",
timeArray: [],
dateArray: [],
valueArray: [],
oldValueArray: [],
isDesktop: false,
popupStyle: {
content: {},
triangle: {}
}
});
const rangeArray = vue.computed(() => {
let val = props2.range;
switch (props2.mode) {
case mode.SELECTOR:
return [val];
case mode.MULTISELECTOR:
return val;
case mode.TIME:
return state.timeArray;
case mode.DATE: {
const dateArray = state.dateArray;
switch (props2.fields) {
case fields.YEAR:
return [dateArray[0]];
case fields.MONTH:
return [dateArray[0], dateArray[1]];
default:
return [dateArray[0], dateArray[1], dateArray[2]];
}
}
}
return [];
});
return {
state,
rangeArray
};
}
function useIsiPad() {
const isiPad = vue.ref(false);
return isiPad;
}
function useSystem() {
const _system = vue.ref("");
return _system;
}
let __contentVisibleDelay;
function usePickerMethods(props2, state, trigger, rootRef, pickerRef, selectRef, inputRef) {
const isiPad = useIsiPad();
const _system = useSystem();
const selectorTypeComputed = vue.computed(() => {
const type = props2.selectorType;
if (Object.values(selectorType).includes(type)) {
return type;
}
return isiPad.value ? selectorType.PICKER : selectorType.SELECT;
});
const system = vue.computed(() => {
if (props2.mode === mode.DATE && !Object.values(fields).includes(props2.fields) && state.isDesktop) {
return _system.value;
}
return "";
});
const startArray = vue.computed(() => {
return getDateValueArray(props2, state, props2.start, getDefaultStartValue(props2));
});
const endArray = vue.computed(() => {
return getDateValueArray(props2, state, props2.end, getDefaultEndValue(props2));
});
function _show(event) {
if (props2.disabled) {
return;
}
state.valueChangeSource = "";
let $picker = pickerRef.value;
let _currentTarget = event.currentTarget;
$picker.remove();
(document.querySelector("uni-app") || document.body).appendChild($picker);
$picker.style.display = "block";
const rect = _currentTarget.getBoundingClientRect();
state.popover = {
top: rect.top,
left: rect.left,
width: rect.width,
height: rect.height
};
setTimeout(() => {
state.visible = true;
}, 20);
}
function _getFormData() {
return {
value: state.valueSync,
key: props2.name
};
}
function _resetFormData() {
switch (props2.mode) {
case mode.SELECTOR:
state.valueSync = 0;
break;
case mode.MULTISELECTOR:
state.valueSync = props2.value.map((val) => 0);
break;
case mode.DATE:
case mode.TIME:
state.valueSync = "";
break;
}
}
function _createTime() {
let hours = [];
let minutes = [];
for (let i = 0; i < 24; i++) {
hours.push((i < 10 ? "0" : "") + i);
}
for (let i = 0; i < 60; i++) {
minutes.push((i < 10 ? "0" : "") + i);
}
state.timeArray.push(hours, minutes);
}
function getYearStartEnd() {
let year = (/* @__PURE__ */ new Date()).getFullYear();
let start = year - 150;
let end = year + 150;
if (props2.start) {
const _year = new Date(props2.start).getFullYear();
if (!isNaN(_year) && _year < start) {
start = _year;
}
}
if (props2.end) {
const _year = new Date(props2.end).getFullYear();
if (!isNaN(_year) && _year > end) {
end = _year;
}
}
return {
start,
end
};
}
function _createDate() {
let years = [];
const year = getYearStartEnd();
for (let i = year.start, end = year.end; i <= end; i++) {
years.push(String(i));
}
let months = [];
for (let i = 1; i <= 12; i++) {
months.push((i < 10 ? "0" : "") + i);
}
let days = [];
for (let i = 1; i <= 31; i++) {
days.push((i < 10 ? "0" : "") + i);
}
state.dateArray.push(years, months, days);
}
function _getTimeValue(val) {
return val[0] * 60 + val[1];
}
function _getDateValue(val) {
const DAY = 31;
return val[0] * DAY * 12 + (val[1] || 0) * DAY + (val[2] || 0);
}
function _cloneArray(val1, val2) {
for (let i = 0; i < val1.length && i < val2.length; i++) {
val1[i] = val2[i];
}
}
function _setValueSync() {
let val = props2.value;
switch (props2.mode) {
case mode.MULTISELECTOR:
{
if (!shared.isArray(val)) {
val = state.valueArray;
}
if (!shared.isArray(state.valueSync)) {
state.valueSync = [];
}
const length = state.valueSync.length = Math.max(val.length, props2.range.length);
for (let index2 = 0; index2 < length; index2++) {
const val0 = Number(val[index2]);
const val1 = Number(state.valueSync[index2]);
const val2 = isNaN(val0) ? isNaN(val1) ? 0 : val1 : val0;
const maxVal = props2.range[index2] ? props2.range[index2].length - 1 : 0;
state.valueSync.splice(index2, 1, val2 < 0 || val2 > maxVal ? 0 : val2);
}
}
break;
case mode.TIME:
case mode.DATE:
state.valueSync = String(val);
break;
default: {
const valueSync = Number(val);
state.valueSync = valueSync < 0 ? 0 : valueSync;
break;
}
}
}
function _setValueArray() {
let val = state.valueSync;
let valueArray;
switch (props2.mode) {
case mode.MULTISELECTOR:
valueArray = [...val];
break;
case mode.TIME:
valueArray = getDateValueArray(props2, state, val, uniShared.formatDateTime({
mode: mode.TIME
}));
break;
case mode.DATE:
valueArray = getDateValueArray(props2, state, val, uniShared.formatDateTime({
mode: mode.DATE
}));
break;
default:
valueArray = [val];
break;
}
state.oldValueArray = [...valueArray];
state.valueArray = [...valueArray];
}
function _getValue() {
let val = state.valueArray;
switch (props2.mode) {
case mode.SELECTOR:
return val[0];
case mode.MULTISELECTOR:
return val.map((val2) => val2);
case mode.TIME:
return state.valueArray.map((val2, i) => state.timeArray[i][val2]).join(":");
case mode.DATE:
return state.valueArray.map((val2, i) => state.dateArray[i][val2]).join("-");
}
}
function _change() {
_close();
state.valueChangeSource = "click";
const value = _getValue();
state.valueSync = shared.isArray(value) ? value.map((val) => val) : value;
trigger("change", {}, {
value
});
}
function _cancel($event) {
if (system.value === "firefox" && $event) {
const {
top,
left,
width,
height
} = state.popover;
const {
pageX,
pageY
} = $event;
if (pageX > left && pageX < left + width && pageY > top && pageY < top + height) {
return;
}
}
_close();
trigger("cancel", {}, {});
}
function _close() {
state.visible = false;
setTimeout(() => {
let $picker = pickerRef.value;
$picker.remove();
rootRef.value.prepend($picker);
$picker.style.display = "none";
}, 260);
}
function _select() {
if (props2.mode === mode.SELECTOR && selectorTypeComputed.value === selectorType.SELECT) {
selectRef.value.scrollTop = state.valueArray[0] * 34;
}
}
function _input($event) {
const EventTarget = $event.target;
state.valueSync = EventTarget.value;
vue.nextTick(() => {
_change();
});
}
function _fixInputPosition($event) {
if (system.value === "chrome") {
const rect = rootRef.value.getBoundingClientRect();
const fontSize = 32;
inputRef.value.style.left = `${$event.clientX - rect.left - fontSize * 1.5}px`;
inputRef.value.style.top = `${$event.clientY - rect.top - fontSize * 0.5}px`;
}
}
function _pickerViewChange(event) {
state.valueArray = _l10nColumn(event.detail.value, true);
}
function _l10nColumn(array, normalize) {
const {
getLocale: getLocale2
} = useI18n();
if (props2.mode === mode.DATE) {
const locale = getLocale2();
if (!locale.startsWith("zh")) {
switch (props2.fields) {
case fields.YEAR:
return array;
case fields.MONTH:
return [array[1], array[0]];
default:
switch (locale) {
case "es":
case "fr":
return [array[2], array[1], array[0]];
default:
return normalize ? [array[2], array[0], array[1]] : [array[1], array[2], array[0]];
}
}
}
}
return array;
}
function _l10nItem(item, index2) {
const {
getLocale: getLocale2
} = useI18n();
if (props2.mode === mode.DATE) {
const locale = getLocale2();
if (locale.startsWith("zh")) {
const array = ["年", "月", "日"];
return item + array[index2];
} else if (props2.fields !== fields.YEAR && index2 === (props2.fields !== fields.MONTH && (locale === "es" || locale === "fr") ? 1 : 0)) {
let array;
switch (locale) {
case "es":
array = ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"];
break;
case "fr":
array = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"];
break;
default:
array = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
break;
}
return array[Number(item) - 1];
}
}
return item;
}
vue.watch(() => state.visible, (val) => {
if (val) {
clearTimeout(__contentVisibleDelay);
state.contentVisible = val;
_select();
} else {
__contentVisibleDelay = setTimeout(() => {
state.contentVisible = val;
}, 300);
}
});
vue.watch([() => props2.mode, () => props2.value, () => props2.range], _setValueSync, {
deep: true
});
vue.watch(() => state.valueSync, _setValueArray, {
deep: true
});
vue.watch(() => state.valueArray, (val) => {
if (props2.mode === mode.TIME || props2.mode === mode.DATE) {
const getValue = props2.mode === mode.TIME ? _getTimeValue : _getDateValue;
const valueArray = state.valueArray;
const _startArray = startArray.value;
const _endArray = endArray.value;
if (props2.mode === mode.DATE) {
const dateArray = state.dateArray;
const max = dateArray[2].length;
const day = Number(dateArray[2][valueArray[2]]) || 1;
const realDay = (/* @__PURE__ */ new Date(`${dateArray[0][valueArray[0]]}/${dateArray[1][valueArray[1]]}/${day}`)).getDate();
if (realDay < day) {
valueArray[2] -= realDay + max - day;
}
}
if (getValue(valueArray) < getValue(_startArray)) {
_cloneArray(valueArray, _startArray);
} else if (getValue(valueArray) > getValue(_endArray)) {
_cloneArray(valueArray, _endArray);
}
}
val.forEach((value, column) => {
if (value !== state.oldValueArray[column]) {
state.oldValueArray[column] = value;
if (props2.mode === mode.MULTISELECTOR) {
trigger("columnchange", {}, {
column,
value
});
}
}
});
});
return {
selectorTypeComputed,
system,
_show,
_cancel,
_change,
_l10nColumn,
_l10nItem,
_input,
_resetFormData,
_getFormData,
_createTime,
_createDate,
_setValueSync,
_fixInputPosition,
_pickerViewChange
};
}
function usePickerWatch(state, _cancel, _change) {
const {
key,
disable
} = useKeyboard();
vue.watchEffect(() => {
disable.value = !state.visible;
});
vue.watch(key, (value) => {
if (value === "esc") {
_cancel();
} else if (value === "enter") {
_change();
}
});
}
function usePickerForm(_resetFormData, _getFormData) {
const uniForm = vue.inject(uniFormKey, false);
if (uniForm) {
const field = {
reset: _resetFormData,
submit: () => {
const data = ["", null];
const {
key,
value
} = _getFormData();
if (key !== "") {
data[0] = key;
data[1] = value;
}
return data;
}
};
uniForm.addField(field);
}
}
const index$6 = /* @__PURE__ */ defineUnsupportedComponent("ad");
const index$5 = /* @__PURE__ */ defineUnsupportedComponent("ad-content-page");
const index$4 = /* @__PURE__ */ defineUnsupportedComponent("ad-draw");
const index$3 = /* @__PURE__ */ defineUnsupportedComponent("camera");
const index$2 = /* @__PURE__ */ defineUnsupportedComponent("live-player");
const index$1 = /* @__PURE__ */ defineUnsupportedComponent("live-pusher");
const UniViewJSBridge$1 = /* @__PURE__ */ shared.extend(ViewJSBridge, {
publishHandler(event, args, pageId) {
UniServiceJSBridge.subscribeHandler(event, args, pageId);
}
});
const request = /* @__PURE__ */ defineTaskApi(
API_REQUEST,
({
url,
data,
header,
method,
dataType: dataType2,
responseType,
withCredentials,
timeout = __uniConfig.networkTimeout.request
}, { resolve, reject }) => {
let body = null;
const contentType = normalizeContentType(header);
if (method !== "GET") {
if (shared.isString(data) || data instanceof ArrayBuffer) {
body = data;
} else {
if (contentType === "json") {
try {
body = JSON.stringify(data);
} catch (error) {
body = data.toString();
}
} else if (contentType === "urlencoded") {
const bodyArray = [];
for (const key in data) {
if (shared.hasOwn(data, key)) {
bodyArray.push(
encodeURIComponent(key) + "=" + encodeURIComponent(data[key])
);
}
}
body = bodyArray.join("&");
} else {
body = data.toString();
}
}
}
const xhr = new XMLHttpRequest();
const requestTask = new RequestTask(xhr);
xhr.open(method, url);
for (const key in header) {
if (shared.hasOwn(header, key)) {
xhr.setRequestHeader(key, header[key]);
}
}
const timer = setTimeout(function() {
xhr.onload = xhr.onabort = xhr.onerror = null;
requestTask.abort();
reject("timeout");
}, timeout);
xhr.responseType = responseType;
xhr.onload = function() {
clearTimeout(timer);
const statusCode = xhr.status;
let res = responseType === "text" ? xhr.responseText : xhr.response;
if (responseType === "text" && dataType2 === "json") {
try {
res = JSON.parse(res);
} catch (error) {
}
}
resolve({
data: res,
statusCode,
header: parseHeaders(xhr.getAllResponseHeaders()),
cookies: []
});
};
xhr.onabort = function() {
clearTimeout(timer);
reject("abort");
};
xhr.onerror = function() {
clearTimeout(timer);
reject();
};
xhr.withCredentials = withCredentials;
xhr.send(body);
return requestTask;
},
RequestProtocol,
RequestOptions
);
function normalizeContentType(header) {
const name = Object.keys(header).find(
(name2) => name2.toLowerCase() === "content-type"
);
if (!name) {
return;
}
const contentType = header[name];
if (name !== "Content-Type") {
header["Content-Type"] = header[name];
delete header[name];
}
if (contentType.indexOf("application/json") === 0) {
return "json";
} else if (contentType.indexOf("application/x-www-form-urlencoded") === 0) {
return "urlencoded";
}
return "string";
}
class RequestTask {
constructor(xhr) {
this._xhr = xhr;
}
abort() {
if (this._xhr) {
this._xhr.abort();
delete this._xhr;
}
}
onHeadersReceived(callback) {
throw new Error("Method not implemented.");
}
offHeadersReceived(callback) {
throw new Error("Method not implemented.");
}
}
function parseHeaders(headers) {
const headersObject = {};
headers.split(uniShared.LINEFEED).forEach((header) => {
const find = header.match(/(\S+\s*):\s*(.*)/);
if (!find || find.length !== 3) {
return;
}
headersObject[find[1]] = find[2];
});
return headersObject;
}
const STORAGE_KEYS = "uni-storage-keys";
function parseValue(value) {
const types = ["object", "string", "number", "boolean", "undefined"];
try {
const object = shared.isString(value) ? JSON.parse(value) : value;
const type = object.type;
if (types.indexOf(type) >= 0) {
const keys = Object.keys(object);
if (keys.length === 2 && "data" in object) {
if (typeof object.data === type) {
return object.data;
}
if (type === "object" && /^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{3}Z$/.test(object.data)) {
return new Date(object.data);
}
} else if (keys.length === 1) {
return "";
}
}
} catch (error) {
}
}
const setStorageSync = /* @__PURE__ */ defineSyncApi(
API_SET_STORAGE_SYNC,
(key, data) => {
const type = typeof data;
const value = type === "string" ? data : JSON.stringify({
type,
data
});
localStorage.setItem(key, value);
},
SetStorageSyncProtocol
);
const setStorage = /* @__PURE__ */ defineAsyncApi(
API_SET_STORAGE,
({ key, data }, { resolve, reject }) => {
try {
setStorageSync(key, data);
resolve();
} catch (error) {
reject(error.message);
}
},
SetStorageProtocol
);
function getStorageOrigin(key) {
const value = localStorage && localStorage.getItem(key);
if (!shared.isString(value)) {
throw new Error("data not found");
}
let data = value;
try {
const object = JSON.parse(value);
const result = parseValue(object);
if (result !== void 0) {
data = result;
}
} catch (error) {
}
return data;
}
const getStorageSync = /* @__PURE__ */ defineSyncApi(
API_GET_STORAGE_SYNC,
(key) => {
try {
return getStorageOrigin(key);
} catch (error) {
return "";
}
},
GetStorageSyncProtocol
);
const getStorage = /* @__PURE__ */ defineAsyncApi(
API_GET_STORAGE,
({ key }, { resolve, reject }) => {
try {
const data = getStorageOrigin(key);
resolve({
data
});
} catch (error) {
reject(error.message);
}
},
GetStorageProtocol
);
const removeStorageSync = /* @__PURE__ */ defineSyncApi(
API_REMOVE_STORAGE,
(key) => {
if (localStorage) {
localStorage.removeItem(key);
}
},
RemoveStorageSyncProtocol
);
const removeStorage = /* @__PURE__ */ defineAsyncApi(
API_REMOVE_STORAGE,
({ key }, { resolve }) => {
removeStorageSync(key);
resolve();
},
RemoveStorageProtocol
);
const clearStorageSync = /* @__PURE__ */ defineSyncApi(
"clearStorageSync",
() => {
if (localStorage) {
localStorage.clear();
}
}
);
const clearStorage = /* @__PURE__ */ defineAsyncApi(
"clearStorage",
(_, { resolve }) => {
clearStorageSync();
resolve();
}
);
const getStorageInfoSync = /* @__PURE__ */ defineSyncApi(
"getStorageInfoSync",
() => {
const length = localStorage && localStorage.length || 0;
const keys = [];
let currentSize = 0;
for (let index2 = 0; index2 < length; index2++) {
const key = localStorage.key(index2);
const value = localStorage.getItem(key) || "";
currentSize += key.length + value.length;
if (key !== STORAGE_KEYS) {
keys.push(key);
}
}
return {
keys,
currentSize: Math.ceil(currentSize * 2 / 1024),
limitSize: Number.MAX_VALUE
};
}
);
const getStorageInfo = /* @__PURE__ */ defineAsyncApi(
"getStorageInfo",
(_, { resolve }) => {
resolve(getStorageInfoSync());
}
);
function getTheme() {
if (__uniConfig.darkmode !== true)
return shared.isString(__uniConfig.darkmode) ? __uniConfig.darkmode : "light";
try {
return window.matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
} catch (error) {
return "light";
}
}
let browserInfo;
function initBrowserInfo() {
{
return browserInfo = {};
}
}
const getDeviceInfo = /* @__PURE__ */ defineSyncApi(
"getDeviceInfo",
() => {
initBrowserInfo();
const {
deviceBrand,
deviceModel,
brand,
model,
platform,
system,
deviceOrientation,
deviceType
} = browserInfo;
return {
brand,
deviceBrand,
deviceModel,
devicePixelRatio: 1,
deviceId: Date.now() + "" + Math.floor(Math.random() * 1e7),
deviceOrientation,
deviceType,
model,
platform,
system
};
}
);
const getAppBaseInfo = /* @__PURE__ */ defineSyncApi(
"getAppBaseInfo",
() => {
initBrowserInfo();
const { theme, language, browserName, browserVersion } = browserInfo;
return {
appId: __uniConfig.appId,
appName: __uniConfig.appName,
appVersion: __uniConfig.appVersion,
appVersionCode: __uniConfig.appVersionCode,
appLanguage: getLocale ? getLocale() : language,
enableDebug: false,
hostSDKVersion: void 0,
hostPackageName: void 0,
hostFontSizeSetting: void 0,
hostName: browserName,
hostVersion: browserVersion,
hostTheme: theme,
hostLanguage: language,
language,
SDKVersion: "",
theme,
version: ""
};
}
);
const getSystemInfoSync = /* @__PURE__ */ defineSyncApi(
"getSystemInfoSync",
() => {
{
return {
deviceId: Date.now() + "" + Math.floor(Math.random() * 1e7),
platform: "nodejs"
};
}
}
);
function updateDocumentTitle(title) {
{
const ssrContext = getApp$1().$.appContext.provides[vue.ssrContextKey];
if (ssrContext) {
ssrContext[uniShared.UNI_SSR_TITLE] = title;
}
}
UniServiceJSBridge.emit(uniShared.ON_NAVIGATION_BAR_CHANGE, { titleText: title });
}
function useDocumentTitle(pageMeta) {
function update() {
updateDocumentTitle(pageMeta.navigationBar.titleText);
}
vue.watchEffect(update);
}
function setNavigationBar(pageMeta, type, args, resolve, reject) {
if (!pageMeta) {
return reject("page not found");
}
const { navigationBar } = pageMeta;
switch (type) {
case API_SET_NAVIGATION_BAR_COLOR:
const { frontColor, backgroundColor, animation: animation2 } = args;
const { duration, timingFunc } = animation2;
if (frontColor) {
navigationBar.titleColor = frontColor === "#000000" ? "#000000" : "#ffffff";
}
if (backgroundColor) {
navigationBar.backgroundColor = backgroundColor;
}
navigationBar.duration = duration + "ms";
navigationBar.timingFunc = timingFunc;
break;
case API_SHOW_NAVIGATION_BAR_LOADING:
navigationBar.loading = true;
break;
case API_HIDE_NAVIGATION_BAR_LOADING:
navigationBar.loading = false;
break;
case API_SET_NAVIGATION_BAR_TITLE:
const { title } = args;
navigationBar.titleText = title;
{
updateDocumentTitle(args.title);
}
break;
}
resolve();
}
const setNavigationBarTitle = /* @__PURE__ */ defineAsyncApi(
API_SET_NAVIGATION_BAR_TITLE,
(args, { resolve, reject }) => {
setNavigationBar(
getCurrentPageMeta(),
API_SET_NAVIGATION_BAR_TITLE,
args,
resolve,
reject
);
},
SetNavigationBarTitleProtocol
);
require("localstorage-polyfill");
global.XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest;
const api = /* @__PURE__ */ Object.defineProperty({
__proto__: null,
clearStorage,
clearStorageSync,
getAppBaseInfo,
getDeviceInfo,
getStorage,
getStorageInfo,
getStorageInfoSync,
getStorageSync,
getSystemInfoSync,
removeStorage,
removeStorageSync,
request,
setNavigationBarTitle,
setStorage,
setStorageSync
}, Symbol.toStringTag, { value: "Module" });
const uni$1 = api;
const UniServiceJSBridge$1 = /* @__PURE__ */ shared.extend(ServiceJSBridge, {
publishHandler(event, args, pageId) {
UniViewJSBridge.subscribeHandler(event, args, pageId);
}
});
function onThemeChange(callback) {
if (__uniConfig.darkmode) {
UniServiceJSBridge.on(uniShared.ON_THEME_CHANGE, callback);
}
}
function parseTheme(pageStyle) {
let parsedStyle = {};
if (__uniConfig.darkmode) {
parsedStyle = uniShared.normalizeStyles(
pageStyle,
__uniConfig.themeConfig,
getTheme()
);
}
return __uniConfig.darkmode ? parsedStyle : pageStyle;
}
function useTheme(pageStyle, onThemeChangeCallback) {
const isReactived = vue.isReactive(pageStyle);
const reactivePageStyle = isReactived ? vue.reactive(parseTheme(pageStyle)) : parseTheme(pageStyle);
if (__uniConfig.darkmode && isReactived) {
vue.watch(pageStyle, (value) => {
const _pageStyle = parseTheme(value);
for (const key in _pageStyle) {
reactivePageStyle[key] = _pageStyle[key];
}
});
}
onThemeChangeCallback && onThemeChange(onThemeChangeCallback);
return reactivePageStyle;
}
const _middleButton = {
width: "50px",
height: "50px",
iconWidth: "24px"
};
const TabBar = /* @__PURE__ */ defineSystemComponent({
name: "TabBar",
setup() {
const visibleList = vue.ref([]);
const _tabBar = useTabBar();
const tabBar2 = useTheme(_tabBar, () => {
const tabBarStyle = parseTheme(_tabBar);
tabBar2.backgroundColor = tabBarStyle.backgroundColor;
tabBar2.borderStyle = tabBarStyle.borderStyle;
tabBar2.color = tabBarStyle.color;
tabBar2.selectedColor = tabBarStyle.selectedColor;
tabBar2.blurEffect = tabBarStyle.blurEffect;
if (tabBarStyle.list && tabBarStyle.list.length) {
tabBarStyle.list.forEach((item, index2) => {
tabBar2.list[index2].iconPath = item.iconPath;
tabBar2.list[index2].selectedIconPath = item.selectedIconPath;
});
}
});
useVisibleList(tabBar2, visibleList);
useTabBarCssVar(tabBar2);
const onSwitchTab = useSwitchTab(vueRouter.useRoute(), tabBar2, visibleList);
const {
style,
borderStyle,
placeholderStyle
} = useTabBarStyle(tabBar2);
return () => {
const tabBarItemsTsx = createTabBarItemsTsx(tabBar2, onSwitchTab, visibleList);
return vue.createVNode("uni-tabbar", {
"class": "uni-tabbar-" + tabBar2.position
}, [vue.createVNode("div", {
"class": "uni-tabbar",
"style": style.value
}, [vue.createVNode("div", {
"class": "uni-tabbar-border",
"style": borderStyle.value
}, null, 4), tabBarItemsTsx], 4), vue.createVNode("div", {
"class": "uni-placeholder",
"style": placeholderStyle.value
}, null, 4)], 2);
};
}
});
function useTabBarCssVar(tabBar2) {
vue.watch(() => tabBar2.shown, (value) => {
updatePageCssVar({
"--window-bottom": normalizeWindowBottom(value ? parseInt(tabBar2.height) : 0)
});
});
}
function useVisibleList(tabBar2, visibleList) {
const internalMidButton = vue.ref(shared.extend({
type: "midButton"
}, tabBar2.midButton));
function setVisibleList() {
let tempList = [];
tempList = tabBar2.list.filter((item) => item.visible !== false);
if (__UNI_FEATURE_TABBAR_MIDBUTTON__ && tabBar2.midButton) {
internalMidButton.value = shared.extend({}, _middleButton, internalMidButton.value, tabBar2.midButton);
tempList = tempList.filter((item) => !isMidButton(item));
if (tempList.length % 2 === 0) {
tempList.splice(Math.floor(tempList.length / 2), 0, internalMidButton.value);
}
}
visibleList.value = tempList;
}
vue.watchEffect(setVisibleList);
}
function useSwitchTab(route, tabBar2, visibleList) {
vue.watchEffect(() => {
const meta = route.meta;
if (meta.isTabBar) {
const pagePath = meta.route;
const index2 = visibleList.value.findIndex((item) => item.pagePath === pagePath);
tabBar2.selectedIndex = index2;
}
});
return (tabBarItem, index2) => {
const {
type
} = tabBarItem;
return () => {
if (__UNI_FEATURE_TABBAR_MIDBUTTON__ && type === "midButton") {
return UniServiceJSBridge.invokeOnCallback(API_ON_TAB_BAR_MID_BUTTON_TAP);
}
const {
pagePath,
text
} = tabBarItem;
let url = uniShared.addLeadingSlash(pagePath);
if (url === __uniRoutes[0].alias) {
url = "/";
}
if (route.path !== url) {
uni.switchTab({
from: "tabBar",
url,
tabBarText: text
});
} else {
invokeHook("onTabItemTap", {
index: index2,
text,
pagePath
});
}
};
};
}
const DEFAULT_BG_COLOR = "#f7f7fa";
const BLUR_EFFECT_COLOR_DARK = "rgb(0, 0, 0, 0.8)";
const BLUR_EFFECT_COLOR_LIGHT = "rgb(250, 250, 250, 0.8)";
const BLUR_EFFECT_COLORS = {
dark: BLUR_EFFECT_COLOR_DARK,
light: BLUR_EFFECT_COLOR_LIGHT,
extralight: BLUR_EFFECT_COLOR_LIGHT
};
const BORDER_COLORS = {
white: "rgba(255, 255, 255, 0.33)",
black: "rgba(0, 0, 0, 0.33)"
};
function useTabBarStyle(tabBar2) {
const style = vue.computed(() => {
let backgroundColor = tabBar2.backgroundColor;
const blurEffect = tabBar2.blurEffect;
if (!backgroundColor) {
if (blurEffect && blurEffect !== "none") {
backgroundColor = BLUR_EFFECT_COLORS[blurEffect];
}
}
return {
backgroundColor: backgroundColor || DEFAULT_BG_COLOR,
backdropFilter: blurEffect !== "none" ? "blur(10px)" : blurEffect
};
});
const borderStyle = vue.computed(() => {
const {
borderStyle: borderStyle2
} = tabBar2;
return {
backgroundColor: BORDER_COLORS[borderStyle2] || borderStyle2
};
});
const placeholderStyle = vue.computed(() => {
return {
height: tabBar2.height
};
});
return {
style,
borderStyle,
placeholderStyle
};
}
function isMidButton(item) {
return item.type === "midButton";
}
function createTabBarItemsTsx(tabBar2, onSwitchTab, visibleList) {
const {
selectedIndex,
selectedColor,
color
} = tabBar2;
return visibleList.value.map((item, index2) => {
const selected = selectedIndex === index2;
const textColor = selected ? selectedColor : color;
const iconPath = (selected ? item.selectedIconPath || item.iconPath : item.iconPath) || "";
const iconfontText = item.iconfont ? selected ? item.iconfont.selectedText || item.iconfont.text : item.iconfont.text : void 0;
const iconfontColor = item.iconfont ? selected ? item.iconfont.selectedColor || item.iconfont.color : item.iconfont.color : void 0;
if (!__UNI_FEATURE_TABBAR_MIDBUTTON__) {
return createTabBarItemTsx(textColor, iconPath, iconfontText, iconfontColor, item, tabBar2, index2, onSwitchTab);
}
return isMidButton(item) ? createTabBarMidButtonTsx(textColor, iconPath, iconfontText, iconfontColor, item, tabBar2, index2, onSwitchTab) : createTabBarItemTsx(textColor, iconPath, iconfontText, iconfontColor, item, tabBar2, index2, onSwitchTab);
});
}
function createTabBarItemTsx(color, iconPath, iconfontText, iconfontColor, tabBarItem, tabBar2, index2, onSwitchTab) {
return vue.createVNode("div", {
"key": index2,
"class": "uni-tabbar__item",
"onClick": onSwitchTab(tabBarItem, index2)
}, [createTabBarItemBdTsx(color, iconPath || "", iconfontText, iconfontColor, tabBarItem, tabBar2)], 8, ["onClick"]);
}
function createTabBarItemBdTsx(color, iconPath, iconfontText, iconfontColor, tabBarItem, tabBar2) {
const {
height
} = tabBar2;
return vue.createVNode("div", {
"class": "uni-tabbar__bd",
"style": {
height
}
}, [iconfontText ? createTabBarItemIconfontTsx(iconfontText, iconfontColor || BLUR_EFFECT_COLOR_DARK, tabBarItem, tabBar2) : iconPath && createTabBarItemIconTsx(iconPath, tabBarItem, tabBar2), tabBarItem.text && createTabBarItemTextTsx(color, tabBarItem, tabBar2), tabBarItem.redDot && createTabBarItemRedDotTsx(tabBarItem.badge)], 4);
}
function createTabBarItemIconTsx(iconPath, tabBarItem, tabBar2) {
const {
type,
text
} = tabBarItem;
const {
iconWidth
} = tabBar2;
const clazz2 = "uni-tabbar__icon" + (text ? " uni-tabbar__icon__diff" : "");
const style = {
width: iconWidth,
height: iconWidth
};
return vue.createVNode("div", {
"class": clazz2,
"style": style
}, [type !== "midButton" && vue.createVNode("img", {
"src": getRealPath(iconPath)
}, null, 8, ["src"])], 6);
}
function createTabBarItemIconfontTsx(iconfontText, iconfontColor, tabBarItem, tabBar2) {
var _a;
const {
type,
text
} = tabBarItem;
const {
iconWidth
} = tabBar2;
const clazz2 = "uni-tabbar__icon" + (text ? " uni-tabbar__icon__diff" : "");
const style = {
width: iconWidth,
height: iconWidth
};
const iconfontStyle = {
fontSize: ((_a = tabBarItem.iconfont) == null ? void 0 : _a.fontSize) || iconWidth,
color: iconfontColor
};
return vue.createVNode("div", {
"class": clazz2,
"style": style
}, [type !== "midButton" && vue.createVNode("div", {
"class": "uni-tabbar__iconfont",
"style": iconfontStyle
}, [iconfontText], 4)], 6);
}
function createTabBarItemTextTsx(color, tabBarItem, tabBar2) {
const {
iconPath,
text
} = tabBarItem;
const {
fontSize,
spacing
} = tabBar2;
const style = {
color,
fontSize,
lineHeight: !iconPath ? 1.8 : "normal",
marginTop: !iconPath ? "inherit" : spacing
};
return vue.createVNode("div", {
"class": "uni-tabbar__label",
"style": style
}, [text], 4);
}
function createTabBarItemRedDotTsx(badge) {
const clazz2 = "uni-tabbar__reddot" + (badge ? " uni-tabbar__badge" : "");
return vue.createVNode("div", {
"class": clazz2
}, [badge], 2);
}
function createTabBarMidButtonTsx(color, iconPath, iconfontText, iconfontColor, midButton, tabBar2, index2, onSwitchTab) {
const {
width,
height,
backgroundImage,
iconWidth
} = midButton;
return vue.createVNode("div", {
"key": "midButton",
"class": "uni-tabbar__item",
"style": {
flex: "0 0 " + width,
position: "relative"
},
"onClick": onSwitchTab(midButton, index2)
}, [vue.createVNode("div", {
"class": "uni-tabbar__mid",
"style": {
width,
height,
backgroundImage: backgroundImage ? "url('" + getRealPath(backgroundImage) + "')" : "none"
}
}, [iconPath && vue.createVNode("img", {
"style": {
width: iconWidth,
height: iconWidth
},
"src": getRealPath(iconPath)
}, null, 12, ["src"])], 4), createTabBarItemBdTsx(color, iconPath, iconfontText, iconfontColor, midButton, tabBar2)], 12, ["onClick"]);
}
const LayoutComponent = /* @__PURE__ */ defineSystemComponent({
name: "Layout",
setup(_props, {
emit: emit2
}) {
const rootRef = vue.ref(null);
const keepAliveRoute = __UNI_FEATURE_PAGES__ && useKeepAliveRoute();
const {
layoutState,
windowState
} = useState();
useMaxWidth(layoutState, rootRef);
const topWindow = __UNI_FEATURE_TOPWINDOW__ && useTopWindow(layoutState);
const leftWindow = __UNI_FEATURE_LEFTWINDOW__ && useLeftWindow(layoutState);
const rightWindow = __UNI_FEATURE_RIGHTWINDOW__ && useRightWindow(layoutState);
const showTabBar = __UNI_FEATURE_TABBAR__ && useShowTabBar();
const clazz2 = useAppClass(showTabBar);
return () => {
const layoutTsx = createLayoutTsx(keepAliveRoute, layoutState, windowState, topWindow, leftWindow, rightWindow);
const tabBarTsx = __UNI_FEATURE_TABBAR__ && createTabBarTsx(showTabBar);
return vue.createVNode("uni-app", {
"ref": rootRef,
"class": clazz2.value
}, [layoutTsx, tabBarTsx], 2);
};
}
});
function useAppClass(showTabBar) {
const showMaxWidth = vue.ref(false);
return vue.computed(() => {
return {
"uni-app--showtabbar": showTabBar && showTabBar.value,
"uni-app--maxwidth": showMaxWidth.value
};
});
}
function initMediaQuery(minWidth, callback) {
{
return false;
}
}
function useMaxWidth(layoutState, rootRef) {
const route = usePageRoute();
function checkMaxWidth() {
const windowWidth = document.body.clientWidth;
const pages = getCurrentPages();
let meta = {};
if (pages.length > 0) {
const curPage = pages[pages.length - 1];
meta = curPage.$page.meta;
} else {
const routeOptions = getRouteOptions(route.path, true);
if (routeOptions) {
meta = routeOptions.meta;
}
}
const maxWidth = parseInt(String((shared.hasOwn(meta, "maxWidth") ? meta.maxWidth : __uniConfig.globalStyle.maxWidth) || Number.MAX_SAFE_INTEGER));
let showMaxWidth = false;
if (windowWidth > maxWidth) {
showMaxWidth = true;
} else {
showMaxWidth = false;
}
if (showMaxWidth && maxWidth) {
layoutState.marginWidth = (windowWidth - maxWidth) / 2;
vue.nextTick(() => {
const rootEl = rootRef.value;
if (rootEl) {
rootEl.setAttribute("style", "max-width:" + maxWidth + "px;margin:0 auto;");
}
});
} else {
layoutState.marginWidth = 0;
vue.nextTick(() => {
const rootEl = rootRef.value;
if (rootEl) {
rootEl.removeAttribute("style");
}
});
}
}
vue.watch([() => route.path], checkMaxWidth);
}
function useState() {
const route = usePageRoute();
if (!__UNI_FEATURE_RESPONSIVE__) {
const layoutState2 = vue.reactive({
marginWidth: 0,
leftWindowWidth: 0,
rightWindowWidth: 0
});
vue.watch(() => layoutState2.marginWidth, (value) => updateCssVar({
"--window-margin": value + "px"
}));
vue.watch(() => layoutState2.leftWindowWidth + layoutState2.marginWidth, (value) => {
updateCssVar({
"--window-left": value + "px"
});
});
vue.watch(() => layoutState2.rightWindowWidth + layoutState2.marginWidth, (value) => {
updateCssVar({
"--window-right": value + "px"
});
});
return {
layoutState: layoutState2,
windowState: vue.computed(() => ({}))
};
}
const topWindowMediaQuery = vue.ref(false);
const leftWindowMediaQuery = vue.ref(false);
const rightWindowMediaQuery = vue.ref(false);
const showTopWindow = vue.computed(() => __UNI_FEATURE_TOPWINDOW__ && route.meta.topWindow !== false && topWindowMediaQuery.value);
const showLeftWindow = vue.computed(() => __UNI_FEATURE_LEFTWINDOW__ && route.meta.leftWindow !== false && leftWindowMediaQuery.value);
const showRightWindow = vue.computed(() => __UNI_FEATURE_RIGHTWINDOW__ && route.meta.rightWindow !== false && rightWindowMediaQuery.value);
const layoutState = vue.reactive({
topWindowMediaQuery,
showTopWindow,
apiShowTopWindow: false,
leftWindowMediaQuery,
showLeftWindow,
apiShowLeftWindow: false,
rightWindowMediaQuery,
showRightWindow,
apiShowRightWindow: false,
topWindowHeight: 0,
marginWidth: 0,
leftWindowWidth: 0,
rightWindowWidth: 0,
navigationBarTitleText: "",
topWindowStyle: {},
leftWindowStyle: {},
rightWindowStyle: {}
});
const props2 = ["topWindow", "leftWindow", "rightWindow"];
props2.forEach((prop) => {
var _a;
const matchMedia = (_a = __uniConfig[prop]) == null ? void 0 : _a.matchMedia;
if (matchMedia && shared.hasOwn(matchMedia, "minWidth")) {
matchMedia.minWidth;
}
const matches = initMediaQuery();
layoutState[`${prop}MediaQuery`] = matches;
});
vue.watch(() => layoutState.topWindowHeight, (value) => updateCssVar({
"--top-window-height": value + "px"
}));
vue.watch(() => layoutState.marginWidth, (value) => updateCssVar({
"--window-margin": value + "px"
}));
vue.watch(() => layoutState.leftWindowWidth + layoutState.marginWidth, (value) => {
updateCssVar({
"--window-left": value + "px"
});
});
vue.watch(() => layoutState.rightWindowWidth + layoutState.marginWidth, (value) => {
updateCssVar({
"--window-right": value + "px"
});
});
UniServiceJSBridge.on(uniShared.ON_NAVIGATION_BAR_CHANGE, (navigationBar) => {
layoutState.navigationBarTitleText = navigationBar.titleText;
});
const windowState = vue.computed(() => ({
matchTopWindow: layoutState.topWindowMediaQuery,
showTopWindow: layoutState.showTopWindow || layoutState.apiShowTopWindow,
matchLeftWindow: layoutState.leftWindowMediaQuery,
showLeftWindow: layoutState.showLeftWindow || layoutState.apiShowLeftWindow,
matchRightWindow: layoutState.rightWindowMediaQuery,
showRightWindow: layoutState.showRightWindow || layoutState.apiShowRightWindow
}));
return {
layoutState,
windowState
};
}
function createLayoutTsx(keepAliveRoute, layoutState, windowState, topWindow, leftWindow, rightWindow) {
const routerVNode = __UNI_FEATURE_PAGES__ ? createRouterViewVNode(keepAliveRoute) : createPageVNode();
if (!__UNI_FEATURE_RESPONSIVE__) {
return routerVNode;
}
const topWindowTsx = __UNI_FEATURE_TOPWINDOW__ ? createTopWindowTsx(topWindow, layoutState, windowState.value) : null;
const leftWindowTsx = __UNI_FEATURE_LEFTWINDOW__ ? createLeftWindowTsx(leftWindow, layoutState, windowState.value) : null;
const rightWindowTsx = __UNI_FEATURE_RIGHTWINDOW__ ? createRightWindowTsx(rightWindow, layoutState, windowState.value) : null;
return vue.createVNode("uni-layout", {
"class": {
"uni-app--showtopwindow": __UNI_FEATURE_TOPWINDOW__ && layoutState.showTopWindow,
"uni-app--showleftwindow": __UNI_FEATURE_LEFTWINDOW__ && layoutState.showLeftWindow,
"uni-app--showrightwindow": __UNI_FEATURE_RIGHTWINDOW__ && layoutState.showRightWindow
}
}, [topWindowTsx, vue.createVNode("uni-content", null, [vue.createVNode("uni-main", null, [routerVNode]), leftWindowTsx, rightWindowTsx])], 2);
}
function useShowTabBar(emit2) {
const route = usePageRoute();
const tabBar2 = useTabBar();
const showTabBar = vue.computed(() => route.meta.isTabBar && tabBar2.shown);
return showTabBar;
}
function createTabBarTsx(showTabBar) {
return vue.withDirectives(vue.createVNode(TabBar, null, null, 512), [[vue.vShow, showTabBar.value]]);
}
function createPageVNode() {
return vue.createVNode(__uniRoutes[0].component);
}
function createRouterViewVNode({
routeKey,
isTabBar,
routeCache: routeCache2
}) {
return vue.createVNode(vueRouter.RouterView, null, {
default: vue.withCtx(({
Component
}) => [(vue.openBlock(), vue.createBlock(vue.KeepAlive, {
matchBy: "key",
cache: routeCache2
}, [(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(Component), {
type: isTabBar.value ? "tabBar" : "",
key: routeKey.value
}))], 1032, ["cache"]))]),
_: 1
/* STABLE */
});
}
function useTopWindow(layoutState) {
const {
component,
style
} = __uniConfig.topWindow;
const windowRef = vue.ref(null);
function updateWindow() {
const instance = windowRef.value;
const el = uniShared.resolveOwnerEl(instance.$);
const height = el.getBoundingClientRect().height;
layoutState.topWindowHeight = height;
}
vue.watch(() => layoutState.showTopWindow || layoutState.apiShowTopWindow, () => vue.nextTick(updateWindow));
layoutState.topWindowStyle = style;
return {
component,
windowRef
};
}
function useLeftWindow(layoutState) {
const {
component,
style
} = __uniConfig.leftWindow;
const windowRef = vue.ref(null);
function updateWindow() {
const instance = windowRef.value;
const el = uniShared.resolveOwnerEl(instance.$);
const width = el.getBoundingClientRect().width;
layoutState.leftWindowWidth = width;
}
vue.watch(() => layoutState.showLeftWindow || layoutState.apiShowLeftWindow, () => vue.nextTick(updateWindow));
layoutState.leftWindowStyle = style;
return {
component,
windowRef
};
}
function useRightWindow(layoutState) {
const {
component,
style
} = __uniConfig.rightWindow;
const windowRef = vue.ref(null);
function updateWindow() {
const instance = windowRef.value;
const el = uniShared.resolveOwnerEl(instance.$);
const width = el.getBoundingClientRect().width;
layoutState.rightWindowWidth = width;
}
vue.watch(() => layoutState.showRightWindow || layoutState.apiShowRightWindow, () => vue.nextTick(updateWindow));
layoutState.rightWindowStyle = style;
return {
component,
windowRef
};
}
function createTopWindowTsx(topWindow, layoutState, windowState) {
if (topWindow) {
const {
component: TopWindow,
windowRef
} = topWindow;
return vue.withDirectives(vue.createVNode("uni-top-window", null, [vue.createVNode("div", {
"class": "uni-top-window",
"style": layoutState.topWindowStyle
}, [vue.createVNode(TopWindow, vue.mergeProps({
"ref": windowRef,
"navigation-bar-title-text": layoutState.navigationBarTitleText
}, windowState), null, 16, ["navigation-bar-title-text"])], 4), vue.createVNode("div", {
"class": "uni-top-window--placeholder",
"style": {
height: layoutState.topWindowHeight + "px"
}
}, null, 4)], 512), [[vue.vShow, layoutState.showTopWindow || layoutState.apiShowTopWindow]]);
}
}
function createLeftWindowTsx(leftWindow, layoutState, windowState) {
if (leftWindow) {
const {
component: LeftWindow,
windowRef
} = leftWindow;
return vue.withDirectives(vue.createVNode("uni-left-window", {
"data-show": layoutState.apiShowLeftWindow || void 0,
"style": layoutState.leftWindowStyle
}, [layoutState.apiShowLeftWindow ? vue.createVNode("div", {
"class": "uni-mask",
"onClick": () => layoutState.apiShowLeftWindow = false
}, null, 8, ["onClick"]) : null, vue.createVNode("div", {
"class": "uni-left-window"
}, [vue.createVNode(LeftWindow, vue.mergeProps({
"ref": windowRef
}, windowState), null, 16)])], 12, ["data-show"]), [[vue.vShow, layoutState.showLeftWindow || layoutState.apiShowLeftWindow]]);
}
}
function createRightWindowTsx(rightWindow, layoutState, windowState) {
if (rightWindow) {
const {
component: RightWindow,
windowRef
} = rightWindow;
return vue.withDirectives(vue.createVNode("uni-right-window", {
"data-show": layoutState.apiShowRightWindow || void 0,
"style": layoutState.rightWindowStyle
}, [layoutState.apiShowRightWindow ? vue.createVNode("div", {
"class": "uni-mask",
"onClick": () => layoutState.apiShowRightWindow = false
}, null, 8, ["onClick"]) : null, vue.createVNode("div", {
"class": "uni-right-window"
}, [vue.createVNode(RightWindow, vue.mergeProps({
"ref": windowRef
}, windowState), null, 16)])], 12, ["data-show"]), [[vue.vShow, layoutState.showRightWindow || layoutState.apiShowRightWindow]]);
}
}
function usePageHeadTransparentBackgroundColor(backgroundColor) {
const { r, g: g2, b } = hexToRgba(backgroundColor);
return `rgba(${r},${g2},${b},0)`;
}
function usePageHeadTransparent(headRef, {
id,
navigationBar: { titleColor, coverage, backgroundColor }
}) {
vue.computed(() => hexToRgba(backgroundColor));
}
const ICON_PATHS = {
none: "",
forward: "M11 7.844q-0.25-0.219-0.25-0.578t0.25-0.578q0.219-0.25 0.563-0.25t0.563 0.25l9.656 9.125q0.125 0.125 0.188 0.297t0.063 0.328q0 0.188-0.063 0.359t-0.188 0.297l-9.656 9.125q-0.219 0.25-0.563 0.25t-0.563-0.25q-0.25-0.219-0.25-0.578t0.25-0.609l9.063-8.594-9.063-8.594z",
back: ICON_PATH_BACK,
select: ICON_PATH_BACK,
share: "M26.563 24.844q0 0.125-0.109 0.234t-0.234 0.109h-17.938q-0.125 0-0.219-0.109t-0.094-0.234v-13.25q0-0.156 0.094-0.25t0.219-0.094h5.5v-1.531h-6q-0.531 0-0.906 0.391t-0.375 0.922v14.375q0 0.531 0.375 0.922t0.906 0.391h18.969q0.531 0 0.891-0.391t0.359-0.953v-5.156h-1.438v4.625zM29.813 10.969l-5.125-5.375-1.031 1.094 3.438 3.594-3.719 0.031q-2.313 0.188-4.344 1.125t-3.578 2.422-2.5 3.453-1.109 4.188l-0.031 0.25h1.469v-0.219q0.156-1.875 1-3.594t2.25-3.063 3.234-2.125 3.828-0.906l0.188-0.031 3.313-0.031-3.438 3.625 1.031 1.063 5.125-5.375-0.031-0.063 0.031-0.063z",
favorite: "M27.594 13.375q-0.063-0.188-0.219-0.313t-0.344-0.156l-7.094-0.969-3.219-6.406q-0.094-0.188-0.25-0.281t-0.375-0.094q-0.188 0-0.344 0.094t-0.25 0.281l-3.125 6.438-7.094 1.094q-0.188 0.031-0.344 0.156t-0.219 0.313q-0.031 0.188 0.016 0.375t0.172 0.313l5.156 4.969-1.156 7.063q-0.031 0.188 0.047 0.375t0.234 0.313q0.094 0.063 0.188 0.094t0.219 0.031q0.063 0 0.141-0.031t0.172-0.063l6.313-3.375 6.375 3.313q0.063 0.031 0.141 0.047t0.172 0.016q0.188 0 0.344-0.094t0.25-0.281q0.063-0.094 0.078-0.234t-0.016-0.234q0-0.031 0-0.063l-1.25-6.938 5.094-5.031q0.156-0.156 0.203-0.344t-0.016-0.375zM11.469 19.063q0.031-0.188-0.016-0.344t-0.172-0.281l-4.406-4.25 6.063-0.906q0.156-0.031 0.297-0.125t0.203-0.25l2.688-5.531 2.75 5.5q0.063 0.156 0.203 0.25t0.297 0.125l6.094 0.844-4.375 4.281q-0.125 0.125-0.172 0.297t-0.016 0.328l1.063 6.031-5.438-2.813q-0.156-0.094-0.328-0.078t-0.297 0.078l-5.438 2.875 1-6.031z",
home: "M23.719 16.5q-0.313 0-0.531 0.219t-0.219 0.5v7.063q0 0.219-0.172 0.391t-0.391 0.172h-12.344q-0.25 0-0.422-0.172t-0.172-0.391v-7.063q0-0.281-0.219-0.5t-0.531-0.219q-0.281 0-0.516 0.219t-0.234 0.5v7.063q0.031 0.844 0.625 1.453t1.438 0.609h12.375q0.844 0 1.453-0.609t0.609-1.453v-7.063q0-0.125-0.063-0.266t-0.156-0.234q-0.094-0.125-0.234-0.172t-0.297-0.047zM26.5 14.875l-8.813-8.813q-0.313-0.313-0.688-0.453t-0.781-0.141-0.781 0.141-0.656 0.422l-8.813 8.844q-0.188 0.219-0.188 0.516t0.219 0.484q0.094 0.125 0.234 0.172t0.297 0.047q0.125 0 0.25-0.047t0.25-0.141l8.781-8.781q0.156-0.156 0.406-0.156t0.406 0.156l8.813 8.781q0.219 0.188 0.516 0.188t0.516-0.219q0.188-0.188 0.203-0.484t-0.172-0.516z",
menu: "M8.938 18.313q0.875 0 1.484-0.609t0.609-1.453-0.609-1.453-1.484-0.609q-0.844 0-1.453 0.609t-0.609 1.453 0.609 1.453 1.453 0.609zM16.188 18.313q0.875 0 1.484-0.609t0.609-1.453-0.609-1.453-1.484-0.609q-0.844 0-1.453 0.609t-0.609 1.453 0.609 1.453 1.453 0.609zM23.469 18.313q0.844 0 1.453-0.609t0.609-1.453-0.609-1.453-1.453-0.609q-0.875 0-1.484 0.609t-0.609 1.453 0.609 1.453 1.484 0.609z",
close: ICON_PATH_CLOSE
};
const PageHead = /* @__PURE__ */ defineSystemComponent({
name: "PageHead",
setup() {
const headRef = vue.ref(null);
const pageMeta = usePageMeta();
const navigationBar = useTheme(pageMeta.navigationBar, () => {
const _navigationBar = parseTheme(pageMeta.navigationBar);
navigationBar.backgroundColor = _navigationBar.backgroundColor;
navigationBar.titleColor = _navigationBar.titleColor;
});
const {
clazz: clazz2,
style
} = usePageHead(navigationBar);
const buttons = __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__ && usePageHeadButtons(pageMeta);
const searchInput = __UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__ && navigationBar.searchInput && usePageHeadSearchInput(pageMeta);
__UNI_FEATURE_NAVIGATIONBAR_TRANSPARENT__ && navigationBar.type === "transparent" && usePageHeadTransparent(headRef, pageMeta);
return () => {
const backButtonTsx = __UNI_FEATURE_PAGES__ ? createBackButtonTsx(navigationBar, pageMeta.isQuit) : null;
const leftButtonsTsx = __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__ ? createButtonsTsx(buttons.left) : [];
const rightButtonsTsx = __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__ ? createButtonsTsx(buttons.right) : [];
const type = navigationBar.type || "default";
const placeholderTsx = type !== "transparent" && type !== "float" && vue.createVNode("div", {
"class": {
"uni-placeholder": true,
"uni-placeholder-titlePenetrate": navigationBar.titlePenetrate
}
}, null, 2);
return vue.createVNode("uni-page-head", {
"uni-page-head-type": type
}, [vue.createVNode("div", {
"ref": headRef,
"class": clazz2.value,
"style": style.value
}, [vue.createVNode("div", {
"class": "uni-page-head-hd"
}, [backButtonTsx, ...leftButtonsTsx]), createPageHeadBdTsx(navigationBar, searchInput), vue.createVNode("div", {
"class": "uni-page-head-ft"
}, [...rightButtonsTsx])], 6), placeholderTsx], 8, ["uni-page-head-type"]);
};
}
});
function createBackButtonTsx(navigationBar, isQuit) {
if (!isQuit) {
return vue.createVNode("div", {
"class": "uni-page-head-btn",
"onClick": onPageHeadBackButton
}, [createSvgIconVNode(ICON_PATH_BACK, navigationBar.type === "transparent" ? "#fff" : navigationBar.titleColor, 27)], 8, ["onClick"]);
}
}
function createButtonsTsx(btns) {
return btns.map(({
onClick,
btnClass,
btnStyle,
btnText,
btnIconPath,
badgeText,
iconStyle,
btnSelect
}, index2) => {
return vue.createVNode("div", {
"key": index2,
"class": btnClass,
"style": btnStyle,
"onClick": onClick,
"badge-text": badgeText
}, [btnIconPath ? createSvgIconVNode(btnIconPath, iconStyle.color, iconStyle.fontSize) : btnSelect ? vue.createVNode("span", {
"style": iconStyle
}, [vue.createVNode("i", {
"class": "uni-btn-icon",
"innerHTML": btnText
}, null, 8, ["innerHTML"]), createSvgIconVNode(ICON_PATHS["select"], "#000", 14)], 4) : vue.createVNode("i", {
"class": "uni-btn-icon",
"style": iconStyle,
"innerHTML": btnText
}, null, 12, ["innerHTML"])], 14, ["onClick", "badge-text"]);
});
}
function createPageHeadBdTsx(navigationBar, searchInput) {
if (!__UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__ || !navigationBar.searchInput) {
return createPageHeadTitleTextTsx(navigationBar);
}
return createPageHeadSearchInputTsx(navigationBar, searchInput);
}
function createPageHeadTitleTextTsx({
type,
loading,
titleSize,
titleText,
titleImage
}) {
return vue.createVNode("div", {
"class": "uni-page-head-bd"
}, [vue.createVNode("div", {
"style": {
fontSize: titleSize,
opacity: type === "transparent" ? 0 : 1
},
"class": "uni-page-head__title"
}, [loading ? vue.createVNode("i", {
"class": "uni-loading"
}, null) : titleImage ? vue.createVNode("img", {
"src": titleImage,
"class": "uni-page-head__title_image"
}, null, 8, ["src"]) : titleText], 4)]);
}
function createPageHeadSearchInputTsx(navigationBar, {
text,
focus,
composing,
onBlur,
onFocus,
onInput,
onConfirm,
onClick
}) {
const {
color,
align,
autoFocus,
disabled,
borderRadius,
backgroundColor,
placeholder,
placeholderColor
} = navigationBar.searchInput;
const searchStyle = {
borderRadius,
backgroundColor
};
const placeholderClass = ["uni-page-head-search-placeholder", `uni-page-head-search-placeholder-${focus.value || text.value ? "left" : align}`];
return vue.createVNode("div", {
"class": "uni-page-head-search",
"style": searchStyle
}, [vue.createVNode("div", {
"style": {
color: placeholderColor
},
"class": placeholderClass
}, [vue.createVNode("div", {
"class": "uni-page-head-search-icon"
}, [createSvgIconVNode(ICON_PATH_SEARCH, placeholderColor, 20)]), text.value || composing.value ? "" : placeholder], 6), disabled ? vue.createVNode(Input, {
"disabled": true,
"style": {
color
},
"placeholder-style": "color: " + placeholderColor,
"class": "uni-page-head-search-input",
"confirm-type": "search",
"onClick": onClick
}, null, 8, ["style", "placeholder-style", "onClick"]) : vue.createVNode(Input, {
"focus": autoFocus,
"style": {
color
},
"placeholder-style": "color: " + placeholderColor,
"class": "uni-page-head-search-input",
"confirm-type": "search",
"onFocus": onFocus,
"onBlur": onBlur,
"onInput": onInput,
"onConfirm": onConfirm
}, null, 8, ["focus", "style", "placeholder-style", "onFocus", "onBlur", "onInput", "onConfirm"])], 4);
}
function onPageHeadBackButton() {
if (getCurrentPages().length === 1) {
uni.reLaunch({
url: "/"
});
} else {
uni.navigateBack({
from: "backbutton",
success() {
}
// 传入空方法，避免返回Promise，因为onBackPress可能导致fail
});
}
}
function usePageHead(navigationBar) {
const clazz2 = vue.computed(() => {
const {
type,
titlePenetrate,
shadowColorType
} = navigationBar;
const clazz3 = {
"uni-page-head": true,
"uni-page-head-transparent": type === "transparent",
"uni-page-head-titlePenetrate": titlePenetrate === "YES",
"uni-page-head-shadow": !!shadowColorType
};
if (shadowColorType) {
clazz3[`uni-page-head-shadow-${shadowColorType}`] = true;
}
return clazz3;
});
const style = vue.computed(() => {
const backgroundColor = __UNI_FEATURE_NAVIGATIONBAR_TRANSPARENT__ && navigationBar.type === "transparent" ? usePageHeadTransparentBackgroundColor(navigationBar.backgroundColor) : navigationBar.backgroundColor;
return {
backgroundColor,
color: navigationBar.titleColor,
transitionDuration: navigationBar.duration,
transitionTimingFunction: navigationBar.timingFunc
};
});
return {
clazz: clazz2,
style
};
}
function usePageHeadButtons({
id,
navigationBar
}) {
const left = [];
const right = [];
const {
buttons
} = navigationBar;
if (shared.isArray(buttons)) {
const {
type
} = navigationBar;
const isTransparent = type === "transparent";
const fonts = /* @__PURE__ */ Object.create(null);
buttons.forEach((btn, index2) => {
if (btn.fontSrc && !btn.fontFamily) {
const fontSrc = getRealPath(btn.fontSrc);
let fontFamily = fonts[fontSrc];
if (!fontFamily) {
fontFamily = `font${Date.now()}`;
fonts[fontSrc] = fontFamily;
}
btn.fontFamily = fontFamily;
}
const pageHeadBtn = usePageHeadButton(id, index2, btn, isTransparent);
if (btn.float === "left") {
left.push(pageHeadBtn);
} else {
right.push(pageHeadBtn);
}
});
}
return {
left,
right
};
}
function usePageHeadButton(pageId, index2, btn, isTransparent) {
const iconStyle = {
color: btn.color,
fontSize: btn.fontSize,
fontWeight: btn.fontWeight
};
if (btn.fontFamily) {
iconStyle.fontFamily = btn.fontFamily;
}
return new Proxy({
btnClass: {
// 类似这样的大量重复的字符串，会在gzip时压缩大小，无需在代码层考虑优化相同字符串
"uni-page-head-btn": true,
"uni-page-head-btn-red-dot": !!(btn.redDot || btn.badgeText),
"uni-page-head-btn-select": !!btn.select
},
btnStyle: {
backgroundColor: isTransparent ? btn.background : "transparent",
width: btn.width
},
btnText: "",
btnIconPath: ICON_PATHS[btn.type],
badgeText: btn.badgeText,
iconStyle,
onClick() {
invokeHook(pageId, uniShared.ON_NAVIGATION_BAR_BUTTON_TAP, shared.extend({
index: index2
}, btn));
},
btnSelect: btn.select
}, {
get(target, key, receiver) {
if (["btnText"].includes(key)) {
return btn.fontSrc && btn.fontFamily ? btn.text.replace("\\u", "&#x") : btn.text;
} else {
return Reflect.get(target, key, receiver);
}
}
});
}
function usePageHeadSearchInput({
id,
navigationBar: {
searchInput
}
}) {
const focus = vue.ref(false);
const text = vue.ref("");
const composing = vue.ref(false);
const {
disabled
} = searchInput;
if (disabled) {
const onClick = () => {
invokeHook(id, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED);
};
return {
focus,
text,
composing,
onClick
};
}
const onFocus = () => {
focus.value = true;
invokeHook(id, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED, {
focus: true
});
};
const onBlur = () => {
focus.value = false;
invokeHook(id, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED, {
focus: false
});
};
const onInput = (evt) => {
text.value = evt.detail.value;
invokeHook(id, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, {
text: text.value
});
};
const onConfirm = (evt) => {
invokeHook(id, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, {
text: text.value
});
};
return {
focus,
text,
composing,
onFocus,
onBlur,
onInput,
onConfirm
};
}
const _sfc_main = {
name: "PageRefresh",
setup() {
const { pullToRefresh } = usePageMeta();
return {
offset: pullToRefresh.offset,
color: pullToRefresh.color
};
}
};
const _export_sfc = (sfc, props2) => {
const target = sfc.__vccOpts || sfc;
for (const [key, val] of props2) {
target[key] = val;
}
return target;
};
const _hoisted_1 = { class: "uni-page-refresh-inner" };
const _hoisted_2 = ["fill"];
const _hoisted_3 = /* @__PURE__ */ vue.createElementVNode("path", { d: "M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z" }, null, -1);
const _hoisted_4 = /* @__PURE__ */ vue.createElementVNode("path", {
d: "M0 0h24v24H0z",
fill: "none"
}, null, -1);
const _hoisted_5 = [
_hoisted_3,
_hoisted_4
];
const _hoisted_6 = {
class: "uni-page-refresh__spinner",
width: "24",
height: "24",
viewBox: "25 25 50 50"
};
const _hoisted_7 = ["stroke"];
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
return vue.openBlock(), vue.createElementBlock("uni-page-refresh", null, [
vue.createElementVNode("div", {
style: vue.normalizeStyle({ "margin-top": $setup.offset + "px" }),
class: "uni-page-refresh"
}, [
vue.createElementVNode("div", _hoisted_1, [
(vue.openBlock(), vue.createElementBlock("svg", {
fill: $setup.color,
class: "uni-page-refresh__icon",
width: "24",
height: "24",
viewBox: "0 0 24 24"
}, _hoisted_5, 8, _hoisted_2)),
(vue.openBlock(), vue.createElementBlock("svg", _hoisted_6, [
vue.createElementVNode("circle", {
stroke: $setup.color,
class: "uni-page-refresh__path",
cx: "50",
cy: "50",
r: "20",
fill: "none",
"stroke-width": "4",
"stroke-miterlimit": "10"
}, null, 8, _hoisted_7)
]))
])
], 4)
]);
}
const PageRefresh = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
const PageBody = defineSystemComponent({
name: "PageBody",
setup(props2, ctx) {
const pageMeta = __UNI_FEATURE_PULL_DOWN_REFRESH__ && usePageMeta();
const refreshRef = __UNI_FEATURE_PULL_DOWN_REFRESH__ && vue.ref(null);
const pageRefresh = null;
return () => {
const pageRefreshTsx = __UNI_FEATURE_PULL_DOWN_REFRESH__ && createPageRefreshTsx(refreshRef, pageMeta);
return vue.createVNode(vue.Fragment, null, [pageRefreshTsx, vue.createVNode("uni-page-wrapper", pageRefresh, [vue.createVNode("uni-page-body", null, [vue.renderSlot(ctx.slots, "default")])], 16)]);
};
}
});
function createPageRefreshTsx(refreshRef, pageMeta) {
if (!__UNI_FEATURE_PULL_DOWN_REFRESH__ || !pageMeta.enablePullDownRefresh) {
return null;
}
return vue.createVNode(PageRefresh, {
"ref": refreshRef
}, null, 512);
}
const index = defineSystemComponent({
name: "Page",
setup(_props, ctx) {
const pageMeta = providePageMeta(getStateId());
const navigationBar = pageMeta.navigationBar;
useDocumentTitle(pageMeta);
return () => vue.createVNode(
"uni-page",
{ "data-page": pageMeta.route },
__UNI_FEATURE_NAVIGATIONBAR__ && navigationBar.style !== "custom" ? [vue.createVNode(PageHead), createPageBodyVNode(ctx)] : [createPageBodyVNode(ctx)]
);
}
});
function createPageBodyVNode(ctx) {
return vue.openBlock(), vue.createBlock(
PageBody,
{ key: 0 },
{
default: vue.withCtx(() => [vue.renderSlot(ctx.slots, "page")]),
_: 3
}
);
}
exports.Ad = index$6;
exports.AdContentPage = index$5;
exports.AdDraw = index$4;
exports.AsyncErrorComponent = AsyncErrorComponent;
exports.AsyncLoadingComponent = AsyncLoadingComponent;
exports.Button = index$A;
exports.Camera = index$3;
exports.Canvas = index$z;
exports.Checkbox = index$x;
exports.CheckboxGroup = index$y;
exports.CoverImage = index$8;
exports.CoverView = index$9;
exports.Editor = index$w;
exports.Form = index$C;
exports.Icon = index$v;
exports.Image = index$u;
exports.Input = Input;
exports.Label = index$B;
exports.LayoutComponent = LayoutComponent;
exports.LivePlayer = index$2;
exports.LivePusher = index$1;
exports.Map = index$a;
exports.MovableArea = index$t;
exports.MovableView = index$s;
exports.Navigator = index$r;
exports.PageComponent = index;
exports.Picker = index$7;
exports.PickerView = PickerView;
exports.PickerViewColumn = PickerViewColumn;
exports.Progress = index$q;
exports.Radio = index$o;
exports.RadioGroup = index$p;
exports.ResizeSensor = ResizeSensor;
exports.RichText = index$n;
exports.ScrollView = index$m;
exports.Slider = index$l;
exports.Swiper = index$k;
exports.SwiperItem = index$j;
exports.Switch = index$i;
exports.Text = index$h;
exports.Textarea = index$g;
exports.UniServiceJSBridge = UniServiceJSBridge$1;
exports.UniViewJSBridge = UniViewJSBridge$1;
exports.Video = index$c;
exports.View = index$f;
exports.WebView = index$b;
exports.clearStorage = clearStorage;
exports.clearStorageSync = clearStorageSync;
exports.getApp = getApp$1;
exports.getAppBaseInfo = getAppBaseInfo;
exports.getCurrentPages = getCurrentPages$1;
exports.getDeviceInfo = getDeviceInfo;
exports.getRealPath = getRealPath;
exports.getStorage = getStorage;
exports.getStorageInfo = getStorageInfo;
exports.getStorageInfoSync = getStorageInfoSync;
exports.getStorageSync = getStorageSync;
exports.getSystemInfoSync = getSystemInfoSync;
exports.plugin = index$d;
exports.removeStorage = removeStorage;
exports.removeStorageSync = removeStorageSync;
exports.request = request;
exports.setNavigationBarTitle = setNavigationBarTitle;
exports.setStorage = setStorage;
exports.setStorageSync = setStorageSync;
exports.setupApp = setupApp;
exports.setupPage = setupPage;
exports.setupWindow = setupWindow;
exports.uni = uni$1;
exports.useI18n = useI18n;
exports.useTabBar = useTabBar;