@cmdless/ui-runtime 0.0.4 → 0.0.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +13 -12
- package/out/main/bin.js +24 -41
- package/out/main/cleanup.js +20 -0
- package/out/main/host.js +79 -0
- package/out/main/hosting.js +448 -0
- package/out/{main/index.js → preload/index.cjs} +1522 -290
- package/out/renderer/assets/Card-BUDQ1UVY.js +15054 -0
- package/out/renderer/assets/Form-B5fhb-x2.css +1121 -0
- package/out/renderer/assets/Form-CE3B5mnl.js +26 -0
- package/out/renderer/assets/Mantine.context-oJEjRkJu.js +574 -0
- package/out/renderer/assets/MantineThemeProvider-DHX5fzKn.js +995 -0
- package/out/renderer/assets/SchemaInput-CACjraGT.js +69 -0
- package/out/renderer/assets/preload-helper-DVzrZ_Op.js +64 -0
- package/out/renderer/assets/use-media-query-d0EeyoH9.js +34 -0
- package/out/renderer/assets/validator-_xTzn1fv.js +31760 -0
- package/out/renderer/assets/view-Chm2p5Ws.js +20542 -0
- package/out/renderer/assets/view-DptMSuIE.css +10034 -0
- package/out/renderer/view.html +21 -0
- package/package.json +23 -6
- package/out/preload/index.mjs +0 -6
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
import { a as reactExports, c as reportHeight, j as jsxRuntimeExports } from "./Mantine.context-oJEjRkJu.js";
|
|
2
|
+
import { C as Container, F as Form$1, v as validator, G as Group, B as Button } from "./validator-_xTzn1fv.js";
|
|
3
|
+
import "./MantineThemeProvider-DHX5fzKn.js";
|
|
4
|
+
import "./use-media-query-d0EeyoH9.js";
|
|
5
|
+
const close = (value) => window.cmdless.view.notify.close({ value });
|
|
6
|
+
function Form({ schema, uiSchema, formData, submitText }) {
|
|
7
|
+
reactExports.useLayoutEffect(reportHeight, []);
|
|
8
|
+
return /* @__PURE__ */ jsxRuntimeExports.jsx(Container, { size: "sm", py: "md", onKeyDown: (event) => event.key === "Escape" && close(), children: /* @__PURE__ */ jsxRuntimeExports.jsx(
|
|
9
|
+
Form$1,
|
|
10
|
+
{
|
|
11
|
+
schema,
|
|
12
|
+
uiSchema,
|
|
13
|
+
formData,
|
|
14
|
+
validator,
|
|
15
|
+
showErrorList: false,
|
|
16
|
+
onSubmit: ({ formData: formData2 }) => close(formData2),
|
|
17
|
+
children: /* @__PURE__ */ jsxRuntimeExports.jsxs(Group, { justify: "flex-end", mt: "lg", children: [
|
|
18
|
+
/* @__PURE__ */ jsxRuntimeExports.jsx(Button, { variant: "default", onClick: () => close(), children: "Cancel" }),
|
|
19
|
+
/* @__PURE__ */ jsxRuntimeExports.jsx(Button, { type: "submit", children: submitText ?? "Submit" })
|
|
20
|
+
] })
|
|
21
|
+
}
|
|
22
|
+
) });
|
|
23
|
+
}
|
|
24
|
+
export {
|
|
25
|
+
Form as default
|
|
26
|
+
};
|
|
@@ -0,0 +1,574 @@
|
|
|
1
|
+
function _mergeNamespaces(n, m) {
|
|
2
|
+
for (var i = 0; i < m.length; i++) {
|
|
3
|
+
const e = m[i];
|
|
4
|
+
if (typeof e !== "string" && !Array.isArray(e)) {
|
|
5
|
+
for (const k in e) {
|
|
6
|
+
if (k !== "default" && !(k in n)) {
|
|
7
|
+
const d = Object.getOwnPropertyDescriptor(e, k);
|
|
8
|
+
if (d) {
|
|
9
|
+
Object.defineProperty(n, k, d.get ? d : {
|
|
10
|
+
enumerable: true,
|
|
11
|
+
get: () => e[k]
|
|
12
|
+
});
|
|
13
|
+
}
|
|
14
|
+
}
|
|
15
|
+
}
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
|
|
19
|
+
}
|
|
20
|
+
function getDefaultExportFromCjs(x) {
|
|
21
|
+
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
|
|
22
|
+
}
|
|
23
|
+
var jsxRuntime = { exports: {} };
|
|
24
|
+
var reactJsxRuntime_production = {};
|
|
25
|
+
var hasRequiredReactJsxRuntime_production;
|
|
26
|
+
function requireReactJsxRuntime_production() {
|
|
27
|
+
if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
|
|
28
|
+
hasRequiredReactJsxRuntime_production = 1;
|
|
29
|
+
var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
|
|
30
|
+
function jsxProd(type, config, maybeKey) {
|
|
31
|
+
var key = null;
|
|
32
|
+
void 0 !== maybeKey && (key = "" + maybeKey);
|
|
33
|
+
void 0 !== config.key && (key = "" + config.key);
|
|
34
|
+
if ("key" in config) {
|
|
35
|
+
maybeKey = {};
|
|
36
|
+
for (var propName in config)
|
|
37
|
+
"key" !== propName && (maybeKey[propName] = config[propName]);
|
|
38
|
+
} else maybeKey = config;
|
|
39
|
+
config = maybeKey.ref;
|
|
40
|
+
return {
|
|
41
|
+
$$typeof: REACT_ELEMENT_TYPE,
|
|
42
|
+
type,
|
|
43
|
+
key,
|
|
44
|
+
ref: void 0 !== config ? config : null,
|
|
45
|
+
props: maybeKey
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
|
|
49
|
+
reactJsxRuntime_production.jsx = jsxProd;
|
|
50
|
+
reactJsxRuntime_production.jsxs = jsxProd;
|
|
51
|
+
return reactJsxRuntime_production;
|
|
52
|
+
}
|
|
53
|
+
var hasRequiredJsxRuntime;
|
|
54
|
+
function requireJsxRuntime() {
|
|
55
|
+
if (hasRequiredJsxRuntime) return jsxRuntime.exports;
|
|
56
|
+
hasRequiredJsxRuntime = 1;
|
|
57
|
+
{
|
|
58
|
+
jsxRuntime.exports = requireReactJsxRuntime_production();
|
|
59
|
+
}
|
|
60
|
+
return jsxRuntime.exports;
|
|
61
|
+
}
|
|
62
|
+
var jsxRuntimeExports = requireJsxRuntime();
|
|
63
|
+
let reported = 0;
|
|
64
|
+
function reportHeight() {
|
|
65
|
+
const height = Math.ceil(document.body.getBoundingClientRect().height);
|
|
66
|
+
if (height === 0 || height === reported) return;
|
|
67
|
+
reported = height;
|
|
68
|
+
window.cmdless.view.notify.resize({ height });
|
|
69
|
+
}
|
|
70
|
+
new ResizeObserver(reportHeight).observe(document.body);
|
|
71
|
+
var react = { exports: {} };
|
|
72
|
+
var react_production = {};
|
|
73
|
+
var hasRequiredReact_production;
|
|
74
|
+
function requireReact_production() {
|
|
75
|
+
if (hasRequiredReact_production) return react_production;
|
|
76
|
+
hasRequiredReact_production = 1;
|
|
77
|
+
var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
|
|
78
|
+
function getIteratorFn(maybeIterable) {
|
|
79
|
+
if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
|
|
80
|
+
maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
|
|
81
|
+
return "function" === typeof maybeIterable ? maybeIterable : null;
|
|
82
|
+
}
|
|
83
|
+
var ReactNoopUpdateQueue = {
|
|
84
|
+
isMounted: function() {
|
|
85
|
+
return false;
|
|
86
|
+
},
|
|
87
|
+
enqueueForceUpdate: function() {
|
|
88
|
+
},
|
|
89
|
+
enqueueReplaceState: function() {
|
|
90
|
+
},
|
|
91
|
+
enqueueSetState: function() {
|
|
92
|
+
}
|
|
93
|
+
}, assign = Object.assign, emptyObject = {};
|
|
94
|
+
function Component(props, context, updater) {
|
|
95
|
+
this.props = props;
|
|
96
|
+
this.context = context;
|
|
97
|
+
this.refs = emptyObject;
|
|
98
|
+
this.updater = updater || ReactNoopUpdateQueue;
|
|
99
|
+
}
|
|
100
|
+
Component.prototype.isReactComponent = {};
|
|
101
|
+
Component.prototype.setState = function(partialState, callback) {
|
|
102
|
+
if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
|
|
103
|
+
throw Error(
|
|
104
|
+
"takes an object of state variables to update or a function which returns an object of state variables."
|
|
105
|
+
);
|
|
106
|
+
this.updater.enqueueSetState(this, partialState, callback, "setState");
|
|
107
|
+
};
|
|
108
|
+
Component.prototype.forceUpdate = function(callback) {
|
|
109
|
+
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
|
|
110
|
+
};
|
|
111
|
+
function ComponentDummy() {
|
|
112
|
+
}
|
|
113
|
+
ComponentDummy.prototype = Component.prototype;
|
|
114
|
+
function PureComponent(props, context, updater) {
|
|
115
|
+
this.props = props;
|
|
116
|
+
this.context = context;
|
|
117
|
+
this.refs = emptyObject;
|
|
118
|
+
this.updater = updater || ReactNoopUpdateQueue;
|
|
119
|
+
}
|
|
120
|
+
var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
|
|
121
|
+
pureComponentPrototype.constructor = PureComponent;
|
|
122
|
+
assign(pureComponentPrototype, Component.prototype);
|
|
123
|
+
pureComponentPrototype.isPureReactComponent = true;
|
|
124
|
+
var isArrayImpl = Array.isArray;
|
|
125
|
+
function noop() {
|
|
126
|
+
}
|
|
127
|
+
var ReactSharedInternals = { H: null, A: null, T: null, S: null }, hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
128
|
+
function ReactElement(type, key, props) {
|
|
129
|
+
var refProp = props.ref;
|
|
130
|
+
return {
|
|
131
|
+
$$typeof: REACT_ELEMENT_TYPE,
|
|
132
|
+
type,
|
|
133
|
+
key,
|
|
134
|
+
ref: void 0 !== refProp ? refProp : null,
|
|
135
|
+
props
|
|
136
|
+
};
|
|
137
|
+
}
|
|
138
|
+
function cloneAndReplaceKey(oldElement, newKey) {
|
|
139
|
+
return ReactElement(oldElement.type, newKey, oldElement.props);
|
|
140
|
+
}
|
|
141
|
+
function isValidElement(object) {
|
|
142
|
+
return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
|
|
143
|
+
}
|
|
144
|
+
function escape(key) {
|
|
145
|
+
var escaperLookup = { "=": "=0", ":": "=2" };
|
|
146
|
+
return "$" + key.replace(/[=:]/g, function(match) {
|
|
147
|
+
return escaperLookup[match];
|
|
148
|
+
});
|
|
149
|
+
}
|
|
150
|
+
var userProvidedKeyEscapeRegex = /\/+/g;
|
|
151
|
+
function getElementKey(element, index) {
|
|
152
|
+
return "object" === typeof element && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
|
|
153
|
+
}
|
|
154
|
+
function resolveThenable(thenable) {
|
|
155
|
+
switch (thenable.status) {
|
|
156
|
+
case "fulfilled":
|
|
157
|
+
return thenable.value;
|
|
158
|
+
case "rejected":
|
|
159
|
+
throw thenable.reason;
|
|
160
|
+
default:
|
|
161
|
+
switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
|
|
162
|
+
function(fulfilledValue) {
|
|
163
|
+
"pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
|
|
164
|
+
},
|
|
165
|
+
function(error) {
|
|
166
|
+
"pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
|
|
167
|
+
}
|
|
168
|
+
)), thenable.status) {
|
|
169
|
+
case "fulfilled":
|
|
170
|
+
return thenable.value;
|
|
171
|
+
case "rejected":
|
|
172
|
+
throw thenable.reason;
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
throw thenable;
|
|
176
|
+
}
|
|
177
|
+
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
|
|
178
|
+
var type = typeof children;
|
|
179
|
+
if ("undefined" === type || "boolean" === type) children = null;
|
|
180
|
+
var invokeCallback = false;
|
|
181
|
+
if (null === children) invokeCallback = true;
|
|
182
|
+
else
|
|
183
|
+
switch (type) {
|
|
184
|
+
case "bigint":
|
|
185
|
+
case "string":
|
|
186
|
+
case "number":
|
|
187
|
+
invokeCallback = true;
|
|
188
|
+
break;
|
|
189
|
+
case "object":
|
|
190
|
+
switch (children.$$typeof) {
|
|
191
|
+
case REACT_ELEMENT_TYPE:
|
|
192
|
+
case REACT_PORTAL_TYPE:
|
|
193
|
+
invokeCallback = true;
|
|
194
|
+
break;
|
|
195
|
+
case REACT_LAZY_TYPE:
|
|
196
|
+
return invokeCallback = children._init, mapIntoArray(
|
|
197
|
+
invokeCallback(children._payload),
|
|
198
|
+
array,
|
|
199
|
+
escapedPrefix,
|
|
200
|
+
nameSoFar,
|
|
201
|
+
callback
|
|
202
|
+
);
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
if (invokeCallback)
|
|
206
|
+
return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
|
|
207
|
+
return c;
|
|
208
|
+
})) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(
|
|
209
|
+
callback,
|
|
210
|
+
escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(
|
|
211
|
+
userProvidedKeyEscapeRegex,
|
|
212
|
+
"$&/"
|
|
213
|
+
) + "/") + invokeCallback
|
|
214
|
+
)), array.push(callback)), 1;
|
|
215
|
+
invokeCallback = 0;
|
|
216
|
+
var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
|
|
217
|
+
if (isArrayImpl(children))
|
|
218
|
+
for (var i = 0; i < children.length; i++)
|
|
219
|
+
nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
|
|
220
|
+
nameSoFar,
|
|
221
|
+
array,
|
|
222
|
+
escapedPrefix,
|
|
223
|
+
type,
|
|
224
|
+
callback
|
|
225
|
+
);
|
|
226
|
+
else if (i = getIteratorFn(children), "function" === typeof i)
|
|
227
|
+
for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
|
|
228
|
+
nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
|
|
229
|
+
nameSoFar,
|
|
230
|
+
array,
|
|
231
|
+
escapedPrefix,
|
|
232
|
+
type,
|
|
233
|
+
callback
|
|
234
|
+
);
|
|
235
|
+
else if ("object" === type) {
|
|
236
|
+
if ("function" === typeof children.then)
|
|
237
|
+
return mapIntoArray(
|
|
238
|
+
resolveThenable(children),
|
|
239
|
+
array,
|
|
240
|
+
escapedPrefix,
|
|
241
|
+
nameSoFar,
|
|
242
|
+
callback
|
|
243
|
+
);
|
|
244
|
+
array = String(children);
|
|
245
|
+
throw Error(
|
|
246
|
+
"Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
|
|
247
|
+
);
|
|
248
|
+
}
|
|
249
|
+
return invokeCallback;
|
|
250
|
+
}
|
|
251
|
+
function mapChildren(children, func, context) {
|
|
252
|
+
if (null == children) return children;
|
|
253
|
+
var result = [], count = 0;
|
|
254
|
+
mapIntoArray(children, result, "", "", function(child) {
|
|
255
|
+
return func.call(context, child, count++);
|
|
256
|
+
});
|
|
257
|
+
return result;
|
|
258
|
+
}
|
|
259
|
+
function lazyInitializer(payload) {
|
|
260
|
+
if (-1 === payload._status) {
|
|
261
|
+
var ctor = payload._result, thenable = ctor();
|
|
262
|
+
thenable.then(
|
|
263
|
+
function(moduleObject) {
|
|
264
|
+
if (0 === payload._status || -1 === payload._status)
|
|
265
|
+
payload._status = 1, payload._result = moduleObject, void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
|
|
266
|
+
},
|
|
267
|
+
function(error) {
|
|
268
|
+
if (0 === payload._status || -1 === payload._status)
|
|
269
|
+
payload._status = 2, payload._result = error, void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error);
|
|
270
|
+
}
|
|
271
|
+
);
|
|
272
|
+
-1 === payload._status && (payload._status = 0, payload._result = thenable);
|
|
273
|
+
}
|
|
274
|
+
if (1 === payload._status) return payload._result.default;
|
|
275
|
+
throw payload._result;
|
|
276
|
+
}
|
|
277
|
+
var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
|
|
278
|
+
if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
|
|
279
|
+
var event = new window.ErrorEvent("error", {
|
|
280
|
+
bubbles: true,
|
|
281
|
+
cancelable: true,
|
|
282
|
+
message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
|
|
283
|
+
error
|
|
284
|
+
});
|
|
285
|
+
if (!window.dispatchEvent(event)) return;
|
|
286
|
+
} else if ("object" === typeof process && "function" === typeof process.emit) {
|
|
287
|
+
process.emit("uncaughtException", error);
|
|
288
|
+
return;
|
|
289
|
+
}
|
|
290
|
+
console.error(error);
|
|
291
|
+
};
|
|
292
|
+
function startTransition(scope) {
|
|
293
|
+
var prevTransition = ReactSharedInternals.T, currentTransition = {};
|
|
294
|
+
currentTransition.types = null !== prevTransition ? prevTransition.types : null;
|
|
295
|
+
ReactSharedInternals.T = currentTransition;
|
|
296
|
+
try {
|
|
297
|
+
var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
|
|
298
|
+
null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
|
|
299
|
+
"object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
|
|
300
|
+
} catch (error) {
|
|
301
|
+
reportGlobalError(error);
|
|
302
|
+
} finally {
|
|
303
|
+
null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
|
|
304
|
+
}
|
|
305
|
+
}
|
|
306
|
+
function addTransitionType(type) {
|
|
307
|
+
var transition = ReactSharedInternals.T;
|
|
308
|
+
if (null !== transition) {
|
|
309
|
+
var transitionTypes = transition.types;
|
|
310
|
+
null === transitionTypes ? transition.types = [type] : -1 === transitionTypes.indexOf(type) && transitionTypes.push(type);
|
|
311
|
+
} else startTransition(addTransitionType.bind(null, type));
|
|
312
|
+
}
|
|
313
|
+
var Children = {
|
|
314
|
+
map: mapChildren,
|
|
315
|
+
forEach: function(children, forEachFunc, forEachContext) {
|
|
316
|
+
mapChildren(
|
|
317
|
+
children,
|
|
318
|
+
function() {
|
|
319
|
+
forEachFunc.apply(this, arguments);
|
|
320
|
+
},
|
|
321
|
+
forEachContext
|
|
322
|
+
);
|
|
323
|
+
},
|
|
324
|
+
count: function(children) {
|
|
325
|
+
var n = 0;
|
|
326
|
+
mapChildren(children, function() {
|
|
327
|
+
n++;
|
|
328
|
+
});
|
|
329
|
+
return n;
|
|
330
|
+
},
|
|
331
|
+
toArray: function(children) {
|
|
332
|
+
return mapChildren(children, function(child) {
|
|
333
|
+
return child;
|
|
334
|
+
}) || [];
|
|
335
|
+
},
|
|
336
|
+
only: function(children) {
|
|
337
|
+
if (!isValidElement(children))
|
|
338
|
+
throw Error(
|
|
339
|
+
"React.Children.only expected to receive a single React element child."
|
|
340
|
+
);
|
|
341
|
+
return children;
|
|
342
|
+
}
|
|
343
|
+
};
|
|
344
|
+
react_production.Activity = REACT_ACTIVITY_TYPE;
|
|
345
|
+
react_production.Children = Children;
|
|
346
|
+
react_production.Component = Component;
|
|
347
|
+
react_production.Fragment = REACT_FRAGMENT_TYPE;
|
|
348
|
+
react_production.Profiler = REACT_PROFILER_TYPE;
|
|
349
|
+
react_production.PureComponent = PureComponent;
|
|
350
|
+
react_production.StrictMode = REACT_STRICT_MODE_TYPE;
|
|
351
|
+
react_production.Suspense = REACT_SUSPENSE_TYPE;
|
|
352
|
+
react_production.ViewTransition = REACT_VIEW_TRANSITION_TYPE;
|
|
353
|
+
react_production.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
|
|
354
|
+
react_production.__COMPILER_RUNTIME = {
|
|
355
|
+
__proto__: null,
|
|
356
|
+
c: function(size) {
|
|
357
|
+
return ReactSharedInternals.H.useMemoCache(size);
|
|
358
|
+
}
|
|
359
|
+
};
|
|
360
|
+
react_production.addTransitionType = addTransitionType;
|
|
361
|
+
react_production.cache = function(fn) {
|
|
362
|
+
return function() {
|
|
363
|
+
return fn.apply(null, arguments);
|
|
364
|
+
};
|
|
365
|
+
};
|
|
366
|
+
react_production.cacheSignal = function() {
|
|
367
|
+
return null;
|
|
368
|
+
};
|
|
369
|
+
react_production.cloneElement = function(element, config, children) {
|
|
370
|
+
if (null === element || void 0 === element)
|
|
371
|
+
throw Error(
|
|
372
|
+
"The argument must be a React element, but you passed " + element + "."
|
|
373
|
+
);
|
|
374
|
+
var props = assign({}, element.props), key = element.key;
|
|
375
|
+
if (null != config)
|
|
376
|
+
for (propName in void 0 !== config.key && (key = "" + config.key), config)
|
|
377
|
+
!hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
|
|
378
|
+
var propName = arguments.length - 2;
|
|
379
|
+
if (1 === propName) props.children = children;
|
|
380
|
+
else if (1 < propName) {
|
|
381
|
+
for (var childArray = Array(propName), i = 0; i < propName; i++)
|
|
382
|
+
childArray[i] = arguments[i + 2];
|
|
383
|
+
props.children = childArray;
|
|
384
|
+
}
|
|
385
|
+
return ReactElement(element.type, key, props);
|
|
386
|
+
};
|
|
387
|
+
react_production.createContext = function(defaultValue) {
|
|
388
|
+
defaultValue = {
|
|
389
|
+
$$typeof: REACT_CONTEXT_TYPE,
|
|
390
|
+
_currentValue: defaultValue,
|
|
391
|
+
_currentValue2: defaultValue,
|
|
392
|
+
_threadCount: 0,
|
|
393
|
+
Provider: null,
|
|
394
|
+
Consumer: null
|
|
395
|
+
};
|
|
396
|
+
defaultValue.Provider = defaultValue;
|
|
397
|
+
defaultValue.Consumer = {
|
|
398
|
+
$$typeof: REACT_CONSUMER_TYPE,
|
|
399
|
+
_context: defaultValue
|
|
400
|
+
};
|
|
401
|
+
return defaultValue;
|
|
402
|
+
};
|
|
403
|
+
react_production.createElement = function(type, config, children) {
|
|
404
|
+
var propName, props = {}, key = null;
|
|
405
|
+
if (null != config)
|
|
406
|
+
for (propName in void 0 !== config.key && (key = "" + config.key), config)
|
|
407
|
+
hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
|
|
408
|
+
var childrenLength = arguments.length - 2;
|
|
409
|
+
if (1 === childrenLength) props.children = children;
|
|
410
|
+
else if (1 < childrenLength) {
|
|
411
|
+
for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
|
|
412
|
+
childArray[i] = arguments[i + 2];
|
|
413
|
+
props.children = childArray;
|
|
414
|
+
}
|
|
415
|
+
if (type && type.defaultProps)
|
|
416
|
+
for (propName in childrenLength = type.defaultProps, childrenLength)
|
|
417
|
+
void 0 === props[propName] && (props[propName] = childrenLength[propName]);
|
|
418
|
+
return ReactElement(type, key, props);
|
|
419
|
+
};
|
|
420
|
+
react_production.createRef = function() {
|
|
421
|
+
return { current: null };
|
|
422
|
+
};
|
|
423
|
+
react_production.forwardRef = function(render) {
|
|
424
|
+
return { $$typeof: REACT_FORWARD_REF_TYPE, render };
|
|
425
|
+
};
|
|
426
|
+
react_production.isValidElement = isValidElement;
|
|
427
|
+
react_production.lazy = function(ctor) {
|
|
428
|
+
return {
|
|
429
|
+
$$typeof: REACT_LAZY_TYPE,
|
|
430
|
+
_payload: { _status: -1, _result: ctor },
|
|
431
|
+
_init: lazyInitializer
|
|
432
|
+
};
|
|
433
|
+
};
|
|
434
|
+
react_production.memo = function(type, compare) {
|
|
435
|
+
return {
|
|
436
|
+
$$typeof: REACT_MEMO_TYPE,
|
|
437
|
+
type,
|
|
438
|
+
compare: void 0 === compare ? null : compare
|
|
439
|
+
};
|
|
440
|
+
};
|
|
441
|
+
react_production.startTransition = startTransition;
|
|
442
|
+
react_production.unstable_useCacheRefresh = function() {
|
|
443
|
+
return ReactSharedInternals.H.useCacheRefresh();
|
|
444
|
+
};
|
|
445
|
+
react_production.use = function(usable) {
|
|
446
|
+
return ReactSharedInternals.H.use(usable);
|
|
447
|
+
};
|
|
448
|
+
react_production.useActionState = function(action, initialState, permalink) {
|
|
449
|
+
return ReactSharedInternals.H.useActionState(action, initialState, permalink);
|
|
450
|
+
};
|
|
451
|
+
react_production.useCallback = function(callback, deps) {
|
|
452
|
+
return ReactSharedInternals.H.useCallback(callback, deps);
|
|
453
|
+
};
|
|
454
|
+
react_production.useContext = function(Context) {
|
|
455
|
+
return ReactSharedInternals.H.useContext(Context);
|
|
456
|
+
};
|
|
457
|
+
react_production.useDebugValue = function() {
|
|
458
|
+
};
|
|
459
|
+
react_production.useDeferredValue = function(value, initialValue) {
|
|
460
|
+
return ReactSharedInternals.H.useDeferredValue(value, initialValue);
|
|
461
|
+
};
|
|
462
|
+
react_production.useEffect = function(create, deps) {
|
|
463
|
+
return ReactSharedInternals.H.useEffect(create, deps);
|
|
464
|
+
};
|
|
465
|
+
react_production.useEffectEvent = function(callback) {
|
|
466
|
+
return ReactSharedInternals.H.useEffectEvent(callback);
|
|
467
|
+
};
|
|
468
|
+
react_production.useId = function() {
|
|
469
|
+
return ReactSharedInternals.H.useId();
|
|
470
|
+
};
|
|
471
|
+
react_production.useImperativeHandle = function(ref, create, deps) {
|
|
472
|
+
return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
|
|
473
|
+
};
|
|
474
|
+
react_production.useInsertionEffect = function(create, deps) {
|
|
475
|
+
return ReactSharedInternals.H.useInsertionEffect(create, deps);
|
|
476
|
+
};
|
|
477
|
+
react_production.useLayoutEffect = function(create, deps) {
|
|
478
|
+
return ReactSharedInternals.H.useLayoutEffect(create, deps);
|
|
479
|
+
};
|
|
480
|
+
react_production.useMemo = function(create, deps) {
|
|
481
|
+
return ReactSharedInternals.H.useMemo(create, deps);
|
|
482
|
+
};
|
|
483
|
+
react_production.useOptimistic = function(passthrough, reducer) {
|
|
484
|
+
return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
|
|
485
|
+
};
|
|
486
|
+
react_production.useReducer = function(reducer, initialArg, init) {
|
|
487
|
+
return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
|
|
488
|
+
};
|
|
489
|
+
react_production.useRef = function(initialValue) {
|
|
490
|
+
return ReactSharedInternals.H.useRef(initialValue);
|
|
491
|
+
};
|
|
492
|
+
react_production.useState = function(initialState) {
|
|
493
|
+
return ReactSharedInternals.H.useState(initialState);
|
|
494
|
+
};
|
|
495
|
+
react_production.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
|
|
496
|
+
return ReactSharedInternals.H.useSyncExternalStore(
|
|
497
|
+
subscribe,
|
|
498
|
+
getSnapshot,
|
|
499
|
+
getServerSnapshot
|
|
500
|
+
);
|
|
501
|
+
};
|
|
502
|
+
react_production.useTransition = function() {
|
|
503
|
+
return ReactSharedInternals.H.useTransition();
|
|
504
|
+
};
|
|
505
|
+
react_production.version = "19.3.1";
|
|
506
|
+
return react_production;
|
|
507
|
+
}
|
|
508
|
+
var hasRequiredReact;
|
|
509
|
+
function requireReact() {
|
|
510
|
+
if (hasRequiredReact) return react.exports;
|
|
511
|
+
hasRequiredReact = 1;
|
|
512
|
+
{
|
|
513
|
+
react.exports = requireReact_production();
|
|
514
|
+
}
|
|
515
|
+
return react.exports;
|
|
516
|
+
}
|
|
517
|
+
var reactExports = requireReact();
|
|
518
|
+
const React = /* @__PURE__ */ getDefaultExportFromCjs(reactExports);
|
|
519
|
+
const React$1 = /* @__PURE__ */ _mergeNamespaces({
|
|
520
|
+
__proto__: null,
|
|
521
|
+
default: React
|
|
522
|
+
}, [reactExports]);
|
|
523
|
+
const MantineContext = reactExports.createContext(null);
|
|
524
|
+
function useMantineContext() {
|
|
525
|
+
const ctx = reactExports.use(MantineContext);
|
|
526
|
+
if (!ctx) throw new Error("[@mantine/core] MantineProvider was not found in tree");
|
|
527
|
+
return ctx;
|
|
528
|
+
}
|
|
529
|
+
function useMantineCssVariablesResolver() {
|
|
530
|
+
return useMantineContext().cssVariablesResolver;
|
|
531
|
+
}
|
|
532
|
+
function useMantineClassNamesPrefix() {
|
|
533
|
+
return useMantineContext().classNamesPrefix;
|
|
534
|
+
}
|
|
535
|
+
function useMantineStyleNonce() {
|
|
536
|
+
return useMantineContext().getStyleNonce;
|
|
537
|
+
}
|
|
538
|
+
function useMantineWithStaticClasses() {
|
|
539
|
+
return useMantineContext().withStaticClasses;
|
|
540
|
+
}
|
|
541
|
+
function useMantineIsHeadless() {
|
|
542
|
+
return useMantineContext().headless;
|
|
543
|
+
}
|
|
544
|
+
function useMantineSxTransform() {
|
|
545
|
+
return useMantineContext().stylesTransform?.sx;
|
|
546
|
+
}
|
|
547
|
+
function useMantineStylesTransform() {
|
|
548
|
+
return useMantineContext().stylesTransform?.styles;
|
|
549
|
+
}
|
|
550
|
+
function useMantineEnv() {
|
|
551
|
+
return useMantineContext().env || "default";
|
|
552
|
+
}
|
|
553
|
+
function useMantineDeduplicateInlineStyles() {
|
|
554
|
+
return useMantineContext().deduplicateInlineStyles;
|
|
555
|
+
}
|
|
556
|
+
export {
|
|
557
|
+
MantineContext as M,
|
|
558
|
+
React as R,
|
|
559
|
+
reactExports as a,
|
|
560
|
+
useMantineCssVariablesResolver as b,
|
|
561
|
+
reportHeight as c,
|
|
562
|
+
useMantineStylesTransform as d,
|
|
563
|
+
useMantineClassNamesPrefix as e,
|
|
564
|
+
useMantineWithStaticClasses as f,
|
|
565
|
+
getDefaultExportFromCjs as g,
|
|
566
|
+
useMantineIsHeadless as h,
|
|
567
|
+
useMantineSxTransform as i,
|
|
568
|
+
jsxRuntimeExports as j,
|
|
569
|
+
useMantineDeduplicateInlineStyles as k,
|
|
570
|
+
React$1 as l,
|
|
571
|
+
useMantineEnv as m,
|
|
572
|
+
requireReact as r,
|
|
573
|
+
useMantineStyleNonce as u
|
|
574
|
+
};
|