@rolder-kit/ui 0.1.0-beta.0 → 0.1.0-beta.1

package/dist/__tests__/formContext.test.js

@@ -0,0 +1,182 @@
+import * as __rspack_external_vitest from "vitest";
+var __webpack_modules__ = {
+    "./src/__tests__/formContext.test.ts" (module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.a(module, async function(__rspack_load_async_deps, __rspack_async_done) {
+            try {
+                __webpack_require__.r(__webpack_exports__);
+                var vitest__rspack_import_0 = __webpack_require__("vitest");
+                vitest__rspack_import_0.vi.mock('@tanstack/react-form', ()=>({
+                        createFormHookContexts: vitest__rspack_import_0.vi.fn(()=>({
+                                fieldContext: 'fieldCtx',
+                                useFieldContext: vitest__rspack_import_0.vi.fn(),
+                                formContext: 'formCtx',
+                                useFormContext: vitest__rspack_import_0.vi.fn()
+                            })),
+                        createFormHook: vitest__rspack_import_0.vi.fn(()=>({
+                                useAppForm: vitest__rspack_import_0.vi.fn(),
+                                withForm: vitest__rspack_import_0.vi.fn()
+                            }))
+                    }));
+                vitest__rspack_import_0.vi.mock('../form/fields', ()=>({
+                        TextField: 'TextField',
+                        NumberField: 'NumberField',
+                        TextareaField: 'TextareaField',
+                        TextPasswordField: 'TextPasswordField',
+                        PasswordField: 'PasswordField',
+                        SelectField: 'SelectField',
+                        MultiSelectField: 'MultiSelectField',
+                        SwitchField: 'SwitchField',
+                        JsonField: 'JsonField'
+                    }));
+                vitest__rspack_import_0.vi.mock('../form/buttons', ()=>({
+                        SubmitButton: 'SubmitButton',
+                        CancelButton: 'CancelButton',
+                        SubscribeButton: 'SubscribeButton',
+                        SubscribeActionIcon: 'SubscribeActionIcon'
+                    }));
+                const { createFormHook, createFormHookContexts } = await import("@tanstack/react-form");
+                const context = await import("../form/context.js");
+                (0, vitest__rspack_import_0.describe)('form context', ()=>{
+                    (0, vitest__rspack_import_0.it)('exports useAppForm', ()=>{
+                        (0, vitest__rspack_import_0.expect)(context.useAppForm).toBeDefined();
+                    });
+                    (0, vitest__rspack_import_0.it)('exports useFieldContext', ()=>{
+                        (0, vitest__rspack_import_0.expect)(context.useFieldContext).toBeDefined();
+                    });
+                    (0, vitest__rspack_import_0.it)('exports useFormContext', ()=>{
+                        (0, vitest__rspack_import_0.expect)(context.useFormContext).toBeDefined();
+                    });
+                    (0, vitest__rspack_import_0.it)('exports withForm', ()=>{
+                        (0, vitest__rspack_import_0.expect)(context.withForm).toBeDefined();
+                    });
+                    (0, vitest__rspack_import_0.it)('calls createFormHookContexts', ()=>{
+                        (0, vitest__rspack_import_0.expect)(createFormHookContexts).toHaveBeenCalled();
+                    });
+                    (0, vitest__rspack_import_0.it)('calls createFormHook with field and form components', ()=>{
+                        (0, vitest__rspack_import_0.expect)(createFormHook).toHaveBeenCalledWith(vitest__rspack_import_0.expect.objectContaining({
+                            fieldContext: 'fieldCtx',
+                            formContext: 'formCtx'
+                        }));
+                    });
+                });
+                __rspack_async_done();
+            } catch (e) {
+                __rspack_async_done(e);
+            }
+        }, 1);
+    },
+    vitest (module) {
+        module.exports = __rspack_external_vitest;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    var hasSymbol = "function" == typeof Symbol;
+    var rspackQueues = hasSymbol ? Symbol("rspack queues") : "__rspack_queues";
+    var rspackExports = __webpack_require__.aE = hasSymbol ? Symbol("rspack exports") : "__webpack_exports__";
+    var rspackError = hasSymbol ? Symbol("rspack error") : "__rspack_error";
+    var rspackDone = hasSymbol ? Symbol("rspack done") : "__rspack_done";
+    var rspackDefer = __webpack_require__.zS = hasSymbol ? Symbol("rspack defer") : "__rspack_defer";
+    var resolveQueue = (queue)=>{
+        if (queue && queue.d < 1) {
+            queue.d = 1;
+            queue.forEach((fn)=>fn.r--);
+            queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
+        }
+    };
+    var wrapDeps = (deps)=>deps.map((dep)=>{
+            if (null !== dep && "object" == typeof dep) {
+                if (!dep[rspackQueues] && dep[rspackDefer]) {
+                    var asyncDeps = dep[rspackDefer];
+                    var hasUnresolvedAsyncSubgraph = asyncDeps.some((id)=>{
+                        var cache = __webpack_module_cache__[id];
+                        return !cache || false === cache[rspackDone];
+                    });
+                    if (!hasUnresolvedAsyncSubgraph) return dep;
+                    var d = dep;
+                    dep = {
+                        then (callback) {
+                            Promise.all(asyncDeps.map(__webpack_require__)).then(()=>callback(d));
+                        }
+                    };
+                }
+                if (dep[rspackQueues]) return dep;
+                if (dep.then) {
+                    var queue = [];
+                    queue.d = 0;
+                    dep.then((r)=>{
+                        obj[rspackExports] = r;
+                        resolveQueue(queue);
+                    }, (e)=>{
+                        obj[rspackError] = e;
+                        resolveQueue(queue);
+                    });
+                    var obj = {};
+                    obj[rspackDefer] = false;
+                    obj[rspackQueues] = (fn)=>fn(queue);
+                    return obj;
+                }
+            }
+            var ret = {};
+            ret[rspackQueues] = ()=>{};
+            ret[rspackExports] = dep;
+            return ret;
+        });
+    __webpack_require__.a = (module, body, hasAwait)=>{
+        var queue;
+        hasAwait && ((queue = []).d = -1);
+        var depQueues = new Set();
+        var exports = module.exports;
+        var currentDeps;
+        var outerResolve;
+        var reject;
+        var promise = new Promise((resolve, rej)=>{
+            reject = rej;
+            outerResolve = resolve;
+        });
+        promise[rspackExports] = exports;
+        promise[rspackQueues] = (fn)=>{
+            queue && fn(queue), depQueues.forEach(fn), promise["catch"](()=>{});
+        };
+        module.exports = promise;
+        var handle = (deps)=>{
+            currentDeps = wrapDeps(deps);
+            var fn;
+            var getResult = ()=>currentDeps.map((d)=>{
+                    if (d[rspackDefer]) return d;
+                    if (d[rspackError]) throw d[rspackError];
+                    return d[rspackExports];
+                });
+            var promise = new Promise((resolve)=>{
+                fn = ()=>resolve(getResult);
+                fn.r = 0;
+                var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
+                currentDeps.map((dep)=>dep[rspackDefer] || dep[rspackQueues](fnQueue));
+            });
+            return fn.r ? promise : getResult();
+        };
+        var done = (err)=>(err ? reject(promise[rspackError] = err) : outerResolve(exports), resolveQueue(queue), promise[rspackDone] = true);
+        body(handle, done);
+        queue && queue.d < 0 && (queue.d = 0);
+    };
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+__webpack_require__("./src/__tests__/formContext.test.ts");