Doormile/doormilebuild
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update wings

Browse Source
This commit is contained in:
Aravind
2026-07-14 11:56:47 +05:30
parent 4b8277af70
commit 07e035dd62
1701 changed files with 0 additions and 461071 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
build/node_modules/next/dist/server/after/after-context.js generated vendored
View File

@@ -1,140 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "AfterContext", {
enumerable: true,
get: function() {
return AfterContext;
}
});
const _pqueue = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/p-queue"));
const _invarianterror = require("../../shared/lib/invariant-error");
const _isthenable = require("../../shared/lib/is-thenable");
const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
const _revalidationutils = require("../revalidation-utils");
const _asynclocalstorage = require("../app-render/async-local-storage");
const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
const _aftertaskasyncstorageexternal = require("../app-render/after-task-async-storage.external");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
class AfterContext {
constructor({ waitUntil, onClose, onTaskError }){
this.workUnitStores = new Set();
this.waitUntil = waitUntil;
this.onClose = onClose;
this.onTaskError = onTaskError;
this.callbackQueue = new _pqueue.default();
this.callbackQueue.pause();
}
after(task) {
if ((0, _isthenable.isThenable)(task)) {
if (!this.waitUntil) {
errorWaitUntilNotAvailable();
}
this.waitUntil(task.catch((error)=>this.reportTaskError('promise', error)));
} else if (typeof task === 'function') {
// TODO(after): implement tracing
this.addCallback(task);
} else {
throw Object.defineProperty(new Error('`after()`: Argument must be a promise or a function'), "__NEXT_ERROR_CODE", {
value: "E50",
enumerable: false,
configurable: true
});
}
}
addCallback(callback) {
// if something is wrong, throw synchronously, bubbling up to the `after` callsite.
if (!this.waitUntil) {
errorWaitUntilNotAvailable();
}
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
if (workUnitStore) {
this.workUnitStores.add(workUnitStore);
}
const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
// This is used for checking if request APIs can be called inside `after`.
// Note that we need to check the phase in which the *topmost* `after` was called (which should be "action"),
// not the current phase (which might be "after" if we're in a nested after).
// Otherwise, we might allow `after(() => headers())`, but not `after(() => after(() => headers()))`.
const rootTaskSpawnPhase = afterTaskStore ? afterTaskStore.rootTaskSpawnPhase // nested after
: workUnitStore == null ? void 0 : workUnitStore.phase // topmost after
;
// this should only happen once.
if (!this.runCallbacksOnClosePromise) {
this.runCallbacksOnClosePromise = this.runCallbacksOnClose();
this.waitUntil(this.runCallbacksOnClosePromise);
}
// Bind the callback to the current execution context (i.e. preserve all currently available ALS-es).
// We do this because we want all of these to be equivalent in every regard except timing:
// after(() => x())
// after(x())
// await x()
const wrappedCallback = (0, _asynclocalstorage.bindSnapshot)(// WARNING: Don't make this a named function. It must be anonymous.
// See: https://github.com/facebook/react/pull/34911
async ()=>{
try {
await _aftertaskasyncstorageexternal.afterTaskAsyncStorage.run({
rootTaskSpawnPhase
}, ()=>callback());
} catch (error) {
this.reportTaskError('function', error);
}
});
this.callbackQueue.add(wrappedCallback);
}
async runCallbacksOnClose() {
await new Promise((resolve)=>this.onClose(resolve));
return this.runCallbacks();
}
async runCallbacks() {
if (this.callbackQueue.size === 0) return;
for (const workUnitStore of this.workUnitStores){
workUnitStore.phase = 'after';
}
const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
if (!workStore) {
throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in AfterContext.runCallbacks'), "__NEXT_ERROR_CODE", {
value: "E547",
enumerable: false,
configurable: true
});
}
return (0, _revalidationutils.withExecuteRevalidates)(workStore, ()=>{
this.callbackQueue.start();
return this.callbackQueue.onIdle();
});
}
reportTaskError(taskKind, error) {
// TODO(after): this is fine for now, but will need better intergration with our error reporting.
// TODO(after): should we log this if we have a onTaskError callback?
console.error(taskKind === 'promise' ? `A promise passed to \`after()\` rejected:` : `An error occurred in a function passed to \`after()\`:`, error);
if (this.onTaskError) {
// this is very defensive, but we really don't want anything to blow up in an error handler
try {
this.onTaskError == null ? void 0 : this.onTaskError.call(this, error);
} catch (handlerError) {
console.error(Object.defineProperty(new _invarianterror.InvariantError('`onTaskError` threw while handling an error thrown from an `after` task', {
cause: handlerError
}), "__NEXT_ERROR_CODE", {
value: "E569",
enumerable: false,
configurable: true
}));
}
}
}
}
function errorWaitUntilNotAvailable() {
throw Object.defineProperty(new Error('`after()` will not work correctly, because `waitUntil` is not available in the current environment.'), "__NEXT_ERROR_CODE", {
value: "E91",
enumerable: false,
configurable: true
});
}
//# sourceMappingURL=after-context.js.map

26
build/node_modules/next/dist/server/after/after.js generated vendored
View File

@@ -1,26 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "after", {
enumerable: true,
get: function() {
return after;
}
});
const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
function after(task) {
const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
if (!workStore) {
// TODO(after): the linked docs page talks about *dynamic* APIs, which after soon won't be anymore
throw Object.defineProperty(new Error('`after` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context'), "__NEXT_ERROR_CODE", {
value: "E468",
enumerable: false,
configurable: true
});
}
const { afterContext } = workStore;
return afterContext.after(task);
}
//# sourceMappingURL=after.js.map

74
build/node_modules/next/dist/server/after/awaiter.js generated vendored
View File

@@ -1,74 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
AwaiterMulti: null,
AwaiterOnce: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
AwaiterMulti: function() {
return AwaiterMulti;
},
AwaiterOnce: function() {
return AwaiterOnce;
}
});
const _invarianterror = require("../../shared/lib/invariant-error");
class AwaiterMulti {
constructor({ onError } = {}){
this.promises = new Set();
this.waitUntil = (promise)=>{
// if a promise settles before we await it, we should drop it --
// storing them indefinitely could result in a memory leak.
const cleanup = ()=>{
this.promises.delete(promise);
};
promise.then(cleanup, (err)=>{
cleanup();
this.onError(err);
});
this.promises.add(promise);
};
this.onError = onError ?? console.error;
}
async awaiting() {
while(this.promises.size > 0){
const promises = Array.from(this.promises);
this.promises.clear();
await Promise.allSettled(promises);
}
}
}
class AwaiterOnce {
constructor(options = {}){
this.done = false;
this.waitUntil = (promise)=>{
if (this.done) {
throw Object.defineProperty(new _invarianterror.InvariantError('Cannot call waitUntil() on an AwaiterOnce that was already awaited'), "__NEXT_ERROR_CODE", {
value: "E563",
enumerable: false,
configurable: true
});
}
return this.awaiter.waitUntil(promise);
};
this.awaiter = new AwaiterMulti(options);
}
async awaiting() {
if (!this.pending) {
this.pending = this.awaiter.awaiting().finally(()=>{
this.done = true;
});
}
return this.pending;
}
}
//# sourceMappingURL=awaiter.js.map

38
build/node_modules/next/dist/server/after/builtin-request-context.js generated vendored
View File

@@ -1,38 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
createLocalRequestContext: null,
getBuiltinRequestContext: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
createLocalRequestContext: function() {
return createLocalRequestContext;
},
getBuiltinRequestContext: function() {
return getBuiltinRequestContext;
}
});
const _asynclocalstorage = require("../app-render/async-local-storage");
function getBuiltinRequestContext() {
const _globalThis = globalThis;
const ctx = _globalThis[NEXT_REQUEST_CONTEXT_SYMBOL];
return ctx == null ? void 0 : ctx.get();
}
const NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for('@next/request-context');
function createLocalRequestContext() {
const storage = (0, _asynclocalstorage.createAsyncLocalStorage)();
return {
get: ()=>storage.getStore(),
run: (value, callback)=>storage.run(value, callback)
};
}
//# sourceMappingURL=builtin-request-context.js.map

21
build/node_modules/next/dist/server/after/index.js generated vendored
View File

@@ -1,21 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && __export(require("./after"));
_export_star(require("./after"), exports);
function _export_star(from, to) {
Object.keys(from).forEach(function(k) {
if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
Object.defineProperty(to, k, {
enumerable: true,
get: function() {
return from[k];
}
});
}
});
return from;
}
//# sourceMappingURL=index.js.map

35
build/node_modules/next/dist/server/after/run-with-after.js generated vendored
View File

@@ -1,35 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "AfterRunner", {
enumerable: true,
get: function() {
return AfterRunner;
}
});
const _detachedpromise = require("../../lib/detached-promise");
const _webonclose = require("../web/web-on-close");
const _awaiter = require("./awaiter");
class AfterRunner {
async executeAfter() {
this.closeController.dispatchClose();
await this.awaiter.awaiting();
// if we got an error while running the callbacks,
// thenthis is a noop, because the promise is already rejected
this.finishedWithoutErrors.resolve();
return this.finishedWithoutErrors.promise;
}
constructor(){
this.awaiter = new _awaiter.AwaiterOnce();
this.closeController = new _webonclose.CloseController();
this.finishedWithoutErrors = new _detachedpromise.DetachedPromise();
this.context = {
waitUntil: this.awaiter.waitUntil.bind(this.awaiter),
onClose: this.closeController.onClose.bind(this.closeController),
onTaskError: (error)=>this.finishedWithoutErrors.reject(error)
};
}
}
//# sourceMappingURL=run-with-after.js.map