@torpor/build 0.1.34 → 0.3.0

package/dist/response.d.ts

@@ -1,166 +1,351 @@
+//#region src/response/badRequest.d.ts
 /**
- * 400 Bad Request
- *
- * The server cannot or will not process the request due to something that is
- * perceived to be a client error (e.g., malformed request syntax, invalid
- * request message framing, or deceptive request routing).
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400
- */
+* 400 Bad Request
+*
+* The HTTP 400 Bad Request client error response status code indicates that the
+* server would not process the request due to something the server considered
+* to be a client error. The reason for a 400 response is typically due to
+* malformed request syntax, invalid request message framing, or deceptive
+* request routing.
+*
+* Clients that receive a 400 response should expect that repeating the request
+* without modification will fail with the same error.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/400
+*/
 declare function badRequest(body?: object | string): Response;
-
-/**
- * 201 Created
- *
- * The request succeeded, and a new resource was created as a result. This is
- * typically the response sent after POST requests, or some PUT requests.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/201
- */
+//#endregion
+//#region src/response/created.d.ts
+/**
+* 201 Created
+*
+* The HTTP 201 Created successful response status code indicates that the HTTP
+* request has led to the creation of a resource. This status code is commonly
+* sent as the result of a POST request.
+*
+* The new resource, or a description and link to the new resource, is created
+* before the response is returned. The newly-created items can be returned in
+* the body of the response message, but must be locatable by the URL of the
+* initiating request or by the URL in the value of the Location header provided
+* with the response.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/201
+*/
 declare function created(body?: object | string): Response;
-
-/**
- * 403 Forbidden
- *
- * The client does not have access rights to the content; that is, it is
- * unauthorized, so the server is refusing to give the requested resource.
- * Unlike 401 Unauthorized, the client's identity is known to the server.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403
- */
+//#endregion
+//#region src/response/forbidden.d.ts
+/**
+* 403 Forbidden
+*
+* The HTTP 403 Forbidden client error response status code indicates that the
+* server understood the request but refused to process it. This status is
+* similar to 401, except that for 403 Forbidden responses, authenticating or
+* re-authenticating makes no difference. The request failure is tied to
+* application logic, such as insufficient permissions to a resource or action.
+*
+* Clients that receive a 403 response should expect that repeating the request
+* without modification will fail with the same error. Server owners may decide
+* to send a 404 response instead of a 403 if acknowledging the existence of a
+* resource to clients with insufficient privileges is not desired.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/403
+*/
 declare function forbidden(body?: object | string): Response;
-
-/**
- * 405 Method Not Allowed
- *
- * The request method is known by the server but is not supported by the target
- * resource. For example, an API may not allow calling DELETE to remove a
- * resource.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
- */
+//#endregion
+//#region src/response/found.d.ts
+/**
+* 302 Found
+*
+* The HTTP 302 Found redirection response status code indicates that the
+* requested resource has been temporarily moved to the URL in the Location
+* header.
+*
+* A browser receiving this status will automatically request the resource at
+* the URL in the Location header, redirecting the user to the new page. Search
+* engines receiving this response will not attribute links to the original URL
+* to the new resource, meaning no SEO value is transferred to the new URL.
+*
+* > Note: In the Fetch Standard, when a user agent receives a 302 in response
+* > to a POST request, it uses the GET method in the subsequent redirection
+* > request, as permitted by the HTTP specification. To avoid user agents
+* > modifying the request, use 307 Temporary Redirect instead, as altering the
+* > method after a 307 response is prohibited.
+*
+* > In cases where you want any request method to be changed to GET, use 303
+* > See Other. This is useful when you want to give a response to a PUT method
+* > that is not the uploaded resource but a confirmation message such as: "you
+* > successfully uploaded XYZ".
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/302
+*/
+declare function permRedirect(location: string): Response;
+//#endregion
+//#region src/response/methodNotAllowed.d.ts
+/**
+* 405 Method Not Allowed
+*
+* The HTTP 405 Method Not Allowed client error response status code indicates
+* that the server knows the request method, but the target resource doesn't
+* support this method. The server must generate an Allow header in a 405
+* response with a list of methods that the target resource currently supports.
+*
+* Improper server-side permissions set on files or directories may cause a 405
+* response when the request would otherwise be expected to succeed.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/405
+*/
 declare function methodNotAllowed(body?: object | string): Response;
-
-/**
- * 308 Permanent Redirect
- *
- * This means that the resource is now permanently located at another URI,
- * specified by the Location: HTTP Response header. This has the same semantics
- * as the 301 Moved Permanently HTTP response code, with the exception that the
- * user agent must not change the HTTP method used: if a POST was used in the
- * first request, a POST must be used in the second request.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/308
- */
-declare function moved(location: string): Response;
-
-/**
- * 404 Not Found
- *
- * The server cannot find the requested resource. In the browser, this means the
- * URL is not recognized. In an API, this can also mean that the endpoint is
- * valid but the resource itself does not exist. Servers may also send this
- * response instead of 403 Forbidden to hide the existence of a resource from an
- * unauthorized client. This response code is probably the most well known due
- * to its frequent occurrence on the web.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404
- */
+//#endregion
+//#region src/response/movedPermanently.d.ts
+/**
+* 301 Moved Permanently
+*
+* The HTTP 301 Moved Permanently redirection response status code indicates
+* that the requested resource has been permanently moved to the URL in the
+* Location header.
+*
+* A browser receiving this status will automatically request the resource at
+* the URL in the Location header, redirecting the user to the new page. Search
+* engines receiving this response will attribute links to the original URL to
+* the redirected resource, passing the SEO ranking to the new URL.
+*
+* > Note: In the Fetch Standard, when a user agent receives a 301 in response
+* > to a POST request, it uses the GET method in the subsequent redirection
+* > request, as permitted by the HTTP specification. To avoid user agents
+* > modifying the request, use 308 Permanent Redirect instead, as altering the
+* > method after a 308 response is prohibited.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/301
+*/
+declare function permRedirect$1(location: string): Response;
+//#endregion
+//#region src/response/notFound.d.ts
+/**
+* 404 Not Found
+*
+* The HTTP 404 Not Found client error response status code indicates that the
+* server cannot find the requested resource. Links that lead to a 404 page are
+* often called broken or dead links and can be subject to link rot.
+*
+* A 404 status code only indicates that the resource is missing without
+* indicating if this is temporary or permanent. If a resource is permanently
+* removed, servers should send the 410 Gone status instead.
+*
+* 404 errors on a website can lead to a poor user experience for your visitors,
+* so the number of broken links (internal and external) should be minimized to
+* prevent frustration for readers. Common causes of 404 responses are mistyped
+* URLs or pages that are moved or deleted without redirection. For more
+* information, see the Redirections in HTTP guide.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/404
+*/
 declare function notFound(body?: object | string): Response;
-
-/**
- * 304 Not Modified
- *
- * This is used for caching purposes. It tells the client that the response has
- * not been modified, so the client can continue to use the same cached version
- * of the response.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/304
- */
+//#endregion
+//#region src/response/notModified.d.ts
+/**
+* 304 Not Modified
+*
+* The HTTP 304 Not Modified redirection response status code indicates that
+* there is no need to retransmit the requested resources.
+*
+* This response code is sent when the request is a conditional GET or HEAD
+* request with an If-None-Match or an If-Modified-Since header and the
+* condition evaluates to 'false'. It confirms that the resource cached by the
+* client is still valid and that the server would have sent a 200 OK response
+* with the resource if the condition evaluated to 'true'. See HTTP caching for
+* more information.
+*
+* The response must not contain a body and must include the headers that would
+* have been sent in an equivalent 200 response, such as:
+*
+* - Cache-Control
+* - Content-Location
+* - Date
+* - ETag
+* - Expires
+* - Vary
+*
+* > Note: Many developer tools' network panels of browsers create extraneous
+* > requests leading to 304 responses, so that access to the local cache is
+* > visible to developers.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/304
+*/
 declare function notModified(location: string): Response;
-
-/**
- * 200 OK
- *
- * The request succeeded. The result meaning of "success" depends on the HTTP
- * method:
- * - GET: The resource has been fetched and transmitted in the message body.
- * - HEAD: The representation headers are included in the response without any
- *   message body.
- * - PUT or POST: The resource describing the result of the action is
- *   transmitted in the message body.
- * - TRACE: The message body contains the request message as received by the
- *   server.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/200
- */
+//#endregion
+//#region src/response/ok.d.ts
+/**
+* 200 OK
+*
+* The HTTP 200 OK successful response status code indicates that a request has
+* succeeded. A 200 OK response is cacheable by default.
+*
+* A 200 OK response has a different meaning and format depending on the HTTP
+* request method. Here's how they vary for different methods:
+*
+* - GET: A resource was retrieved by the server and included in the response
+*   body.
+* - POST: An action succeeded; the response has a message body describing the
+*   result.
+* - HEAD: Identical to GET, except there is no message body.
+* - TRACE: The response has a message body containing the request as received
+*   by the server.
+*
+* Although possible, successful PUT or DELETE requests often do not result in a
+* 200 OK response. It is more common to see 201 Created if the resource is
+* uploaded or created for the first time, or 204 No Content upon successful
+* deletion of a resource.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/200
+*/
 declare function ok(body?: object | string): Response;
-
-/**
- * 307 Temporary Redirect
- *
- * The server sends this response to direct the client to get the requested
- * resource at another URI with the same method that was used in the prior
- * request. This has the same semantics as the 302 Found HTTP response code,
- * with the exception that the user agent must not change the HTTP method used:
- * if a POST was used in the first request, a POST must be used in the second
- * request.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/307
- */
-declare function redirect(location: string): Response;
-
-/**
- * Creates a response with the supplied status code and optional body.
- *
- * If the body is an object, it will be converted to JSON and the content-type
- * header set to "application/json". Otherwise, if the body is a string, the
- * content-type header will be set to "text/plain".
- */
+//#endregion
+//#region src/response/permanentRedirect.d.ts
+/**
+* 308 Permanent Redirect
+*
+* The HTTP 308 Permanent Redirect redirection response status code indicates
+* that the requested resource has been permanently moved to the URL given by
+* the Location header.
+*
+* A browser receiving this status will automatically request the resource at
+* the URL in the Location header, redirecting the user to the new page. Search
+* engines receiving this response will attribute links to the original URL to
+* the redirected resource, passing the SEO ranking to the new URL.
+*
+* The request method and the body will not be modified by the client in the
+* redirected request. A 301 Moved Permanently requires the request method and
+* the body to remain unchanged when redirection is performed, but this is
+* incorrectly handled by older clients to use the GET method instead.
+*
+* > Note: Some Web applications may use the 308 Permanent Redirect in a
+* > non-standard way and for different purposes. For example, Google Drive uses
+* > a 308 Resume Incomplete response to indicate to the client when an
+* > unfinished upload has stalled. See Perform a resumable download on the
+* > Google Drive documentation for more information.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/308
+*/
+declare function permanentRedirect(location: string): Response;
+//#endregion
+//#region src/response/response.d.ts
+/**
+* Creates a response with the supplied status code and optional body.
+*
+* If the body is an object, it will be converted to JSON and the content-type
+* header set to "application/json". Otherwise, if the body is a string, the
+* content-type header will be set to "text/plain".
+*/
 declare function response(status: number, body?: object | string): Response;
-
-/**
- * 303 See Other
- *
- * The server sent this response to direct the client to get the requested
- * resource at another URI with a GET request.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/303
- */
+//#endregion
+//#region src/response/seeOther.d.ts
+/**
+* 303 See Other
+*
+* The HTTP 303 See Other redirection response status code indicates that the
+* browser should redirect to the URL in the Location header instead of
+* rendering the requested resource.
+*
+* This response code is often sent back as a result of PUT or POST methods so
+* the client may retrieve a confirmation, or view a representation of a
+* real-world object (see HTTP range-14). The method to retrieve the redirected
+* resource is always GET.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/303
+*/
 declare function seeOther(location: string): Response;
-
-/**
- * 500 Server Error
- *
- * The server has encountered a situation it does not know how to handle.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500
- */
+//#endregion
+//#region src/response/serverError.d.ts
+/**
+* 500 Server Error
+*
+* The HTTP 500 Internal Server Error server error response status code
+* indicates that the server encountered an unexpected condition that prevented
+* it from fulfilling the request. This error is a generic "catch-all" response
+* to server issues, indicating that the server cannot find a more appropriate
+* 5XX error to respond with.
+*
+* If you're a visitor seeing 500 errors on a web page, these issues require
+* investigation by server owners or administrators. There are many possible
+* causes of 500 errors, including: improper server configuration, out-of-memory
+* (OOM) issues, unhandled exceptions, improper file permissions, or other
+* complex factors. Server administrators may proactively log occurrences of
+* server error responses, like the 500 status code, with details about the
+* initiating requests to improve the stability of a service in the future.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/500
+*/
 declare function serverError(body?: object | string): Response;
-
+//#endregion
+//#region src/response/temporaryRedirect.d.ts
 /**
- * Creates a redirect response with the supplied status code.
- */
+* 307 Temporary Redirect
+*
+* The HTTP 307 Temporary Redirect redirection response status code indicates
+* that the resource requested has been temporarily moved to the URL in the
+* Location header.
+*
+* A browser receiving this status will automatically request the resource at
+* the URL in the Location header, redirecting the user to the new page. Search
+* engines receiving this response will not attribute links to the original URL
+* to the new resource, meaning no SEO value is transferred to the new URL.
+*
+* The method and the body of the original request are reused to perform the
+* redirected request. In the cases where you want the request method to be
+* changed to GET, use 303 See Other instead. This is useful when you want to
+* give an answer to a successful PUT request that is not the uploaded resource,
+* but a status monitor or confirmation message like "You have successfully
+* uploaded XYZ".
+*
+* The difference between 307 and 302 is that 307 guarantees that the client
+* will not change the request method and body when the redirected request is
+* made. With 302, older clients incorrectly changed the method to GET. 307 and
+* 302 responses are identical when the request method is GET.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/307
+*/
+declare function temporaryRedirect(location: string): Response;
+//#endregion
+//#region src/response/transfer.d.ts
+/**
+* Creates a redirect response with the supplied status code.
+*/
 declare function transfer(status: 300 | 301 | 302 | 303 | 304 | 307 | 308, location: string): Response;
-
-/**
- * 401 Unauthorized
- *
- * Although the HTTP standard specifies "unauthorized", semantically this
- * response means "unauthenticated". That is, the client must authenticate
- * itself to get the requested response.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401
- */
+//#endregion
+//#region src/response/unauthorized.d.ts
+/**
+* 401 Unauthorized
+*
+* The HTTP 401 Unauthorized client error response status code indicates that a
+* request was not successful because it lacks valid authentication credentials
+* for the requested resource. This status code is sent with an HTTP
+* WWW-Authenticate response header that contains information on the
+* authentication scheme the server expects the client to include to make the
+* request successfully.
+*
+* A 401 Unauthorized is similar to the 403 Forbidden response, except that a
+* 403 is returned when a request contains valid credentials, but the client
+* does not have permissions to perform a certain action.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/401
+*/
 declare function unauthorized(body?: object | string): Response;
-
-/**
- * 422 Unprocessable Content
- *
- * The request was well-formed but was unable to be followed due to semantic errors.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/422
- */
+//#endregion
+//#region src/response/unprocessable.d.ts
+/**
+* 422 Unprocessable Content
+*
+* The HTTP 422 Unprocessable Content client error response status code
+* indicates that the server understood the content type of the request content,
+* and the syntax of the request content was correct, but it was unable to
+* process the contained instructions.
+*
+* Clients that receive a 422 response should expect that repeating the request
+* without modification will fail with the same error.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/422
+*/
 declare function unprocessable(body?: object | string): Response;
-
-export { badRequest, created, forbidden, methodNotAllowed, moved, notFound, notModified, ok, redirect, response, seeOther, serverError, transfer, unauthorized, unprocessable };
+//#endregion
+export { badRequest, created, forbidden, permRedirect as found, methodNotAllowed, permRedirect$1 as movedPermanently, notFound, notModified, ok, permanentRedirect, response, seeOther, serverError, temporaryRedirect, transfer, unauthorized, unprocessable };
+//# sourceMappingURL=response.d.ts.map

package/dist/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","names":[],"sources":["../src/response/badRequest.ts","../src/response/created.ts","../src/response/forbidden.ts","../src/response/found.ts","../src/response/methodNotAllowed.ts","../src/response/movedPermanently.ts","../src/response/notFound.ts","../src/response/notModified.ts","../src/response/ok.ts","../src/response/permanentRedirect.ts","../src/response/response.ts","../src/response/seeOther.ts","../src/response/serverError.ts","../src/response/temporaryRedirect.ts","../src/response/transfer.ts","../src/response/unauthorized.ts","../src/response/unprocessable.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBAgBwB,UAAA,0BAAoC;;;;;;;;;;;;;;;;;;iBCCpC,OAAA,0BAAiC;;;;;;;;;;;;;;;;;;;iBCCjC,SAAA,0BAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AIGnC,iBHMA,YAAA,CGNkC,QAAA,EAAA,MAAA,CAAA,EHMF,QGNE;;;;;;;;;;;;;;;;AHMlC,iBCZA,gBAAA,CDYgC,IAAA,CAAA,EAAA,MAAA,GAAA,MAAA,CAAA,ECZU,QDYV;;;;;;;;;;;;;;;;;;;;;;;iBELhC,cAAA,oBAAgC;;;;;;;;;;;;;;;;;;;;;;iBCDhC,QAAA,0BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACUlC,iBAAA,WAAA,CAA+B,QAAA,EAAA,MAAA,CAAA,EAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCL/B,EAAA,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;AFL5B,iBGMA,iBAAA,CHNkC,QAAA,EAAA,MAAA,CAAA,EGMG,QHNH;;;;;;;;;;iBIdlC,QAAA,0CAAkD;;;;;;;;;;;;;;;;;iBCSlD,QAAA,oBAA4B;;;;;;;;;;;;;;;;;;;;;;iBCK5B,WAAA,0BAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCOrC,iBAAA,oBAAqC;;;;;;iBCzBrC,QAAA,qEAGrB;;;;;;;;;;;;;;;;;;;iBCYqB,YAAA,0BAAsC;;;;;;;;;;;;;;;;AZStC,iBaZA,aAAA,CbYgC,IAAA,CAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EaZO,QbYP"}

package/dist/response.js

@@ -1,37 +1,4 @@
-import {
-  badRequest,
-  created,
-  forbidden,
-  methodNotAllowed,
-  moved,
-  notModified,
-  redirect,
-  serverError,
-  unauthorized,
-  unprocessable
-} from "./chunk-B2UNTYN5.js";
-import {
-  notFound,
-  ok,
-  response,
-  seeOther,
-  transfer
-} from "./chunk-WVXAN4IV.js";
-export {
-  badRequest,
-  created,
-  forbidden,
-  methodNotAllowed,
-  moved,
-  notFound,
-  notModified,
-  ok,
-  redirect,
-  response,
-  seeOther,
-  serverError,
-  transfer,
-  unauthorized,
-  unprocessable
-};
-//# sourceMappingURL=response.js.map
+import { notFound, ok, response, seeOther, transfer } from "./seeOther-BmehiI4C.js";
+import { badRequest, created, forbidden, methodNotAllowed, notModified, permRedirect as permRedirect$1, permRedirect$1 as permRedirect, permanentRedirect, serverError, temporaryRedirect, unauthorized, unprocessable } from "./response-D-XpIuMH.js";
+
+export { badRequest, created, forbidden, permRedirect as found, methodNotAllowed, permRedirect$1 as movedPermanently, notFound, notModified, ok, permanentRedirect, response, seeOther, serverError, temporaryRedirect, transfer, unauthorized, unprocessable };