2022-01-20 02:10:16 -05:00
|
|
|
|
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
|
|
|
|
/// <reference no-default-lib="true" />
|
|
|
|
|
/// <reference lib="esnext" />
|
2021-06-28 19:43:03 -04:00
|
|
|
|
/// <reference lib="deno.net" />
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-07-10 22:38:15 -04:00
|
|
|
|
/** Deno provides extra properties on `import.meta`. These are included here
|
2020-08-31 22:18:06 -04:00
|
|
|
|
* to ensure that these are still available when using the Deno namespace in
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* conjunction with other type libs, like `dom`.
|
|
|
|
|
*
|
|
|
|
|
* @category ES Modules
|
|
|
|
|
*/
|
2020-07-03 06:44:45 -04:00
|
|
|
|
declare interface ImportMeta {
|
|
|
|
|
/** A string representation of the fully qualified module URL. */
|
|
|
|
|
url: string;
|
|
|
|
|
|
|
|
|
|
/** A flag that indicates if the current module is the main module that was
|
|
|
|
|
* called when starting the program under Deno.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* if (import.meta.main) {
|
|
|
|
|
* // this was loaded as the main module, maybe do some bootstrapping
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
|
|
|
|
*/
|
|
|
|
|
main: boolean;
|
2022-07-18 14:05:26 -04:00
|
|
|
|
|
|
|
|
|
/** A function that returns resolved specifier as if it would be imported
|
|
|
|
|
* using `import(specifier)`.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* console.log(import.meta.resolve("./foo.js"));
|
|
|
|
|
* // file:///dev/foo.js
|
|
|
|
|
* ```
|
|
|
|
|
*/
|
|
|
|
|
resolve(specifier: string): string;
|
2020-07-03 06:44:45 -04:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-10 22:38:15 -04:00
|
|
|
|
/** Deno supports user timing Level 3 (see: https://w3c.github.io/user-timing)
|
|
|
|
|
* which is not widely supported yet in other runtimes. These types are here
|
|
|
|
|
* so that these features are still available when using the Deno namespace
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* in conjunction with other type libs, like `dom`.
|
|
|
|
|
*
|
|
|
|
|
* @category Performance API
|
|
|
|
|
*/
|
2020-07-10 22:38:15 -04:00
|
|
|
|
declare interface Performance {
|
|
|
|
|
/** Stores a timestamp with the associated name (a "mark"). */
|
|
|
|
|
mark(markName: string, options?: PerformanceMarkOptions): PerformanceMark;
|
|
|
|
|
|
|
|
|
|
/** Stores the `DOMHighResTimeStamp` duration between two marks along with the
|
|
|
|
|
* associated name (a "measure"). */
|
|
|
|
|
measure(
|
|
|
|
|
measureName: string,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: PerformanceMeasureOptions,
|
2020-07-10 22:38:15 -04:00
|
|
|
|
): PerformanceMeasure;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/**
|
|
|
|
|
* @category Performance API
|
|
|
|
|
*/
|
2020-07-10 22:38:15 -04:00
|
|
|
|
declare interface PerformanceMarkOptions {
|
|
|
|
|
/** Metadata to be included in the mark. */
|
2020-11-03 10:19:29 -05:00
|
|
|
|
// deno-lint-ignore no-explicit-any
|
2020-07-10 22:38:15 -04:00
|
|
|
|
detail?: any;
|
|
|
|
|
|
|
|
|
|
/** Timestamp to be used as the mark time. */
|
|
|
|
|
startTime?: number;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/**
|
|
|
|
|
* @category Performance API
|
|
|
|
|
*/
|
2020-07-10 22:38:15 -04:00
|
|
|
|
declare interface PerformanceMeasureOptions {
|
|
|
|
|
/** Metadata to be included in the measure. */
|
2020-11-03 10:19:29 -05:00
|
|
|
|
// deno-lint-ignore no-explicit-any
|
2020-07-10 22:38:15 -04:00
|
|
|
|
detail?: any;
|
|
|
|
|
|
|
|
|
|
/** Timestamp to be used as the start time or string to be used as start
|
2021-09-02 18:28:12 -04:00
|
|
|
|
* mark. */
|
2020-07-10 22:38:15 -04:00
|
|
|
|
start?: string | number;
|
|
|
|
|
|
|
|
|
|
/** Duration between the start and end times. */
|
|
|
|
|
duration?: number;
|
|
|
|
|
|
|
|
|
|
/** Timestamp to be used as the end time or string to be used as end mark. */
|
|
|
|
|
end?: string | number;
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 11:11:33 -04:00
|
|
|
|
declare namespace Deno {
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** A set of error constructors that are raised by Deno APIs.
|
|
|
|
|
*
|
|
|
|
|
* @category Errors
|
|
|
|
|
*/
|
2021-07-26 14:40:24 -04:00
|
|
|
|
export namespace errors {
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class NotFound extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class PermissionDenied extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class ConnectionRefused extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class ConnectionReset extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class ConnectionAborted extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class NotConnected extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class AddrInUse extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class AddrNotAvailable extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class BrokenPipe extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class AlreadyExists extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class InvalidData extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class TimedOut extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class Interrupted extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class WriteZero extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class UnexpectedEof extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class BadResource extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class Http extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2021-08-15 09:17:07 -04:00
|
|
|
|
export class Busy extends Error {}
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Errors */
|
2022-01-19 22:29:37 -05:00
|
|
|
|
export class NotSupported extends Error {}
|
2021-07-26 14:40:24 -04:00
|
|
|
|
}
|
2020-05-05 16:54:25 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** The current process id of the runtime.
|
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
|
|
|
|
*/
|
2020-05-18 21:51:54 -04:00
|
|
|
|
export const pid: number;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2021-06-21 21:03:00 -04:00
|
|
|
|
/**
|
|
|
|
|
* The pid of the current process's parent.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
2021-06-21 21:03:00 -04:00
|
|
|
|
*/
|
|
|
|
|
export const ppid: number;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Runtime Environment */
|
2021-06-21 21:03:00 -04:00
|
|
|
|
export interface MemoryUsage {
|
|
|
|
|
rss: number;
|
|
|
|
|
heapTotal: number;
|
|
|
|
|
heapUsed: number;
|
|
|
|
|
external: number;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns an object describing the memory usage of the Deno process measured
|
|
|
|
|
* in bytes.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
2021-06-21 21:03:00 -04:00
|
|
|
|
*/
|
|
|
|
|
export function memoryUsage(): MemoryUsage;
|
|
|
|
|
|
2021-04-25 23:59:22 -04:00
|
|
|
|
/** Reflects the `NO_COLOR` environment variable at program start.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* See: https://no-color.org/
|
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
|
|
|
|
*/
|
2020-05-18 21:51:54 -04:00
|
|
|
|
export const noColor: boolean;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2022-03-10 19:35:33 -05:00
|
|
|
|
export type PermissionOptions = "inherit" | "none" | PermissionOptionsObject;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2022-03-10 19:35:33 -05:00
|
|
|
|
export interface PermissionOptionsObject {
|
2022-03-25 07:30:20 -04:00
|
|
|
|
/** Specifies if the `env` permission should be requested or revoked.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
* If set to `"inherit"`, the current `env` permission will be inherited.
|
2022-03-25 07:30:20 -04:00
|
|
|
|
* If set to `true`, the global `env` permission will be requested.
|
|
|
|
|
* If set to `false`, the global `env` permission will be revoked.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*/
|
|
|
|
|
env?: "inherit" | boolean | string[];
|
|
|
|
|
|
|
|
|
|
/** Specifies if the `hrtime` permission should be requested or revoked.
|
|
|
|
|
* If set to `"inherit"`, the current `hrtime` permission will be inherited.
|
|
|
|
|
* If set to `true`, the global `hrtime` permission will be requested.
|
|
|
|
|
* If set to `false`, the global `hrtime` permission will be revoked.
|
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*/
|
|
|
|
|
hrtime?: "inherit" | boolean;
|
|
|
|
|
|
|
|
|
|
/** Specifies if the `net` permission should be requested or revoked.
|
|
|
|
|
* if set to `"inherit"`, the current `net` permission will be inherited.
|
|
|
|
|
* if set to `true`, the global `net` permission will be requested.
|
|
|
|
|
* if set to `false`, the global `net` permission will be revoked.
|
|
|
|
|
* if set to `string[]`, the `net` permission will be requested with the
|
|
|
|
|
* specified host strings with the format `"<host>[:<port>]`.
|
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*
|
|
|
|
|
* Examples:
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "inherit",
|
|
|
|
|
* permissions: {
|
|
|
|
|
* net: "inherit",
|
|
|
|
|
* },
|
|
|
|
|
* async fn() {
|
|
|
|
|
* const status = await Deno.permissions.query({ name: "net" })
|
|
|
|
|
* assertEquals(status.state, "granted");
|
|
|
|
|
* },
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "true",
|
|
|
|
|
* permissions: {
|
|
|
|
|
* net: true,
|
|
|
|
|
* },
|
|
|
|
|
* async fn() {
|
|
|
|
|
* const status = await Deno.permissions.query({ name: "net" });
|
|
|
|
|
* assertEquals(status.state, "granted");
|
|
|
|
|
* },
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "false",
|
|
|
|
|
* permissions: {
|
|
|
|
|
* net: false,
|
|
|
|
|
* },
|
|
|
|
|
* async fn() {
|
|
|
|
|
* const status = await Deno.permissions.query({ name: "net" });
|
|
|
|
|
* assertEquals(status.state, "denied");
|
|
|
|
|
* },
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "localhost:8080",
|
|
|
|
|
* permissions: {
|
|
|
|
|
* net: ["localhost:8080"],
|
|
|
|
|
* },
|
|
|
|
|
* async fn() {
|
|
|
|
|
* const status = await Deno.permissions.query({ name: "net", host: "localhost:8080" });
|
|
|
|
|
* assertEquals(status.state, "granted");
|
|
|
|
|
* },
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
|
|
|
|
*/
|
|
|
|
|
net?: "inherit" | boolean | string[];
|
|
|
|
|
|
|
|
|
|
/** Specifies if the `ffi` permission should be requested or revoked.
|
|
|
|
|
* If set to `"inherit"`, the current `ffi` permission will be inherited.
|
|
|
|
|
* If set to `true`, the global `ffi` permission will be requested.
|
|
|
|
|
* If set to `false`, the global `ffi` permission will be revoked.
|
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*/
|
|
|
|
|
ffi?: "inherit" | boolean | Array<string | URL>;
|
|
|
|
|
|
|
|
|
|
/** Specifies if the `read` permission should be requested or revoked.
|
|
|
|
|
* If set to `"inherit"`, the current `read` permission will be inherited.
|
|
|
|
|
* If set to `true`, the global `read` permission will be requested.
|
|
|
|
|
* If set to `false`, the global `read` permission will be revoked.
|
|
|
|
|
* If set to `Array<string | URL>`, the `read` permission will be requested with the
|
|
|
|
|
* specified file paths.
|
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*/
|
|
|
|
|
read?: "inherit" | boolean | Array<string | URL>;
|
|
|
|
|
|
|
|
|
|
/** Specifies if the `run` permission should be requested or revoked.
|
|
|
|
|
* If set to `"inherit"`, the current `run` permission will be inherited.
|
|
|
|
|
* If set to `true`, the global `run` permission will be requested.
|
|
|
|
|
* If set to `false`, the global `run` permission will be revoked.
|
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*/
|
|
|
|
|
run?: "inherit" | boolean | Array<string | URL>;
|
|
|
|
|
|
|
|
|
|
/** Specifies if the `write` permission should be requested or revoked.
|
|
|
|
|
* If set to `"inherit"`, the current `write` permission will be inherited.
|
|
|
|
|
* If set to `true`, the global `write` permission will be requested.
|
|
|
|
|
* If set to `false`, the global `write` permission will be revoked.
|
|
|
|
|
* If set to `Array<string | URL>`, the `write` permission will be requested with the
|
|
|
|
|
* specified file paths.
|
|
|
|
|
*
|
2022-03-15 20:43:14 -04:00
|
|
|
|
* Defaults to `false`.
|
2022-03-10 19:35:33 -05:00
|
|
|
|
*/
|
|
|
|
|
write?: "inherit" | boolean | Array<string | URL>;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Testing */
|
2021-10-11 09:45:02 -04:00
|
|
|
|
export interface TestContext {
|
2022-04-06 10:51:38 -04:00
|
|
|
|
/**
|
|
|
|
|
* The current test name.
|
|
|
|
|
*/
|
|
|
|
|
name: string;
|
|
|
|
|
/**
|
|
|
|
|
* File Uri of the current test code.
|
|
|
|
|
*/
|
|
|
|
|
origin: string;
|
|
|
|
|
/**
|
|
|
|
|
* Parent test context.
|
|
|
|
|
*/
|
|
|
|
|
parent?: TestContext;
|
|
|
|
|
|
2022-01-18 15:02:56 -05:00
|
|
|
|
/** Run a sub step of the parent test or step. Returns a promise
|
|
|
|
|
* that resolves to a boolean signifying if the step completed successfully.
|
|
|
|
|
* The returned promise never rejects unless the arguments are invalid.
|
|
|
|
|
* If the test was ignored the promise returns `false`.
|
|
|
|
|
*/
|
|
|
|
|
step(t: TestStepDefinition): Promise<boolean>;
|
|
|
|
|
|
|
|
|
|
/** Run a sub step of the parent test or step. Returns a promise
|
|
|
|
|
* that resolves to a boolean signifying if the step completed successfully.
|
|
|
|
|
* The returned promise never rejects unless the arguments are invalid.
|
|
|
|
|
* If the test was ignored the promise returns `false`.
|
|
|
|
|
*/
|
|
|
|
|
step(
|
|
|
|
|
name: string,
|
|
|
|
|
fn: (t: TestContext) => void | Promise<void>,
|
|
|
|
|
): Promise<boolean>;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Testing */
|
2022-01-18 15:02:56 -05:00
|
|
|
|
export interface TestStepDefinition {
|
|
|
|
|
fn: (t: TestContext) => void | Promise<void>;
|
2022-04-06 10:51:38 -04:00
|
|
|
|
/**
|
|
|
|
|
* The current test name.
|
|
|
|
|
*/
|
2022-01-18 15:02:56 -05:00
|
|
|
|
name: string;
|
|
|
|
|
ignore?: boolean;
|
|
|
|
|
/** Check that the number of async completed ops after the test step is the same
|
|
|
|
|
* as number of dispatched ops. Defaults to the parent test or step's value. */
|
|
|
|
|
sanitizeOps?: boolean;
|
|
|
|
|
/** Ensure the test step does not "leak" resources - ie. the resource table
|
|
|
|
|
* after the test has exactly the same contents as before the test. Defaults
|
|
|
|
|
* to the parent test or step's value. */
|
|
|
|
|
sanitizeResources?: boolean;
|
|
|
|
|
/** Ensure the test step does not prematurely cause the process to exit,
|
|
|
|
|
* for example via a call to `Deno.exit`. Defaults to the parent test or
|
|
|
|
|
* step's value. */
|
|
|
|
|
sanitizeExit?: boolean;
|
2021-10-11 09:45:02 -04:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Testing */
|
2020-02-11 06:01:56 -05:00
|
|
|
|
export interface TestDefinition {
|
2021-10-11 09:45:02 -04:00
|
|
|
|
fn: (t: TestContext) => void | Promise<void>;
|
2022-04-06 10:51:38 -04:00
|
|
|
|
/**
|
|
|
|
|
* The current test name.
|
|
|
|
|
*/
|
2020-02-11 06:01:56 -05:00
|
|
|
|
name: string;
|
2020-03-19 05:58:12 -04:00
|
|
|
|
ignore?: boolean;
|
2021-05-19 03:33:01 -04:00
|
|
|
|
/** If at least one test has `only` set to true, only run tests that have
|
2020-06-12 11:58:04 -04:00
|
|
|
|
* `only` set to true and fail the test suite. */
|
|
|
|
|
only?: boolean;
|
2020-04-27 18:56:22 -04:00
|
|
|
|
/** Check that the number of async completed ops after the test is the same
|
2021-09-02 18:28:12 -04:00
|
|
|
|
* as number of dispatched ops. Defaults to true. */
|
2020-04-23 08:40:16 -04:00
|
|
|
|
sanitizeOps?: boolean;
|
2020-04-27 18:56:22 -04:00
|
|
|
|
/** Ensure the test case does not "leak" resources - ie. the resource table
|
|
|
|
|
* after the test has exactly the same contents as before the test. Defaults
|
|
|
|
|
* to true. */
|
2020-04-23 08:40:16 -04:00
|
|
|
|
sanitizeResources?: boolean;
|
2021-02-24 07:55:50 -05:00
|
|
|
|
/** Ensure the test case does not prematurely cause the process to exit,
|
|
|
|
|
* for example via a call to `Deno.exit`. Defaults to true. */
|
|
|
|
|
sanitizeExit?: boolean;
|
2021-10-31 14:45:37 -04:00
|
|
|
|
|
|
|
|
|
/** Specifies the permissions that should be used to run the test.
|
|
|
|
|
* Set this to "inherit" to keep the calling thread's permissions.
|
|
|
|
|
* Set this to "none" to revoke all permissions.
|
|
|
|
|
*
|
|
|
|
|
* Defaults to "inherit".
|
|
|
|
|
*/
|
2022-03-10 19:35:33 -05:00
|
|
|
|
permissions?: PermissionOptions;
|
2020-02-11 06:01:56 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Register a test which will be run when `deno test` is used on the command
|
2020-04-27 08:51:22 -04:00
|
|
|
|
* line and the containing module looks like a test module.
|
|
|
|
|
* `fn` can be async if required.
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "example test",
|
|
|
|
|
* fn(): void {
|
|
|
|
|
* assertEquals("world", "world");
|
|
|
|
|
* },
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "example ignored test",
|
2020-05-23 10:16:57 -04:00
|
|
|
|
* ignore: Deno.build.os === "windows",
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* fn(): void {
|
|
|
|
|
* // This test is ignored only on Windows machines
|
|
|
|
|
* },
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({
|
|
|
|
|
* name: "example async test",
|
|
|
|
|
* async fn() {
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello_world.txt");
|
2020-05-23 10:16:57 -04:00
|
|
|
|
* assertEquals(decoder.decode(data), "Hello world");
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* }
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Testing
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*/
|
2020-02-11 06:01:56 -05:00
|
|
|
|
export function test(t: TestDefinition): void;
|
2020-03-31 23:21:37 -04:00
|
|
|
|
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Register a test which will be run when `deno test` is used on the command
|
2020-04-27 08:51:22 -04:00
|
|
|
|
* line and the containing module looks like a test module.
|
|
|
|
|
* `fn` can be async if required.
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
* Deno.test("My test description", (): void => {
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* assertEquals("hello", "hello");
|
|
|
|
|
* });
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
* Deno.test("My async test description", async (): Promise<void> => {
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello_world.txt");
|
2020-05-23 10:16:57 -04:00
|
|
|
|
* assertEquals(decoder.decode(data), "Hello world");
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* });
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Testing
|
2021-09-02 18:28:12 -04:00
|
|
|
|
*/
|
2021-10-11 09:45:02 -04:00
|
|
|
|
export function test(
|
|
|
|
|
name: string,
|
|
|
|
|
fn: (t: TestContext) => void | Promise<void>,
|
|
|
|
|
): void;
|
2020-04-01 04:47:23 -04:00
|
|
|
|
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
/** Register a test which will be run when `deno test` is used on the command
|
|
|
|
|
* line and the containing module looks like a test module.
|
|
|
|
|
* `fn` can be async if required. Declared function must have a name.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test(function myTestName(): void {
|
|
|
|
|
* assertEquals("hello", "hello");
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* Deno.test(async function myOtherTestName(): Promise<void> {
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello_world.txt");
|
|
|
|
|
* assertEquals(decoder.decode(data), "Hello world");
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Testing
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
*/
|
|
|
|
|
export function test(fn: (t: TestContext) => void | Promise<void>): void;
|
|
|
|
|
|
|
|
|
|
/** Register a test which will be run when `deno test` is used on the command
|
|
|
|
|
* line and the containing module looks like a test module.
|
|
|
|
|
* `fn` can be async if required.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test("My test description", { permissions: { read: true } }, (): void => {
|
|
|
|
|
* assertEquals("hello", "hello");
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* Deno.test("My async test description", { permissions: { read: false } }, async (): Promise<void> => {
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello_world.txt");
|
|
|
|
|
* assertEquals(decoder.decode(data), "Hello world");
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Testing
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
*/
|
|
|
|
|
export function test(
|
|
|
|
|
name: string,
|
|
|
|
|
options: Omit<TestDefinition, "fn" | "name">,
|
|
|
|
|
fn: (t: TestContext) => void | Promise<void>,
|
|
|
|
|
): void;
|
|
|
|
|
|
|
|
|
|
/** Register a test which will be run when `deno test` is used on the command
|
|
|
|
|
* line and the containing module looks like a test module.
|
|
|
|
|
* `fn` can be async if required.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({ name: "My test description", permissions: { read: true } }, (): void => {
|
|
|
|
|
* assertEquals("hello", "hello");
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({ name: "My async test description", permissions: { read: false } }, async (): Promise<void> => {
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello_world.txt");
|
|
|
|
|
* assertEquals(decoder.decode(data), "Hello world");
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Testing
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
*/
|
|
|
|
|
export function test(
|
|
|
|
|
options: Omit<TestDefinition, "fn">,
|
|
|
|
|
fn: (t: TestContext) => void | Promise<void>,
|
|
|
|
|
): void;
|
|
|
|
|
|
|
|
|
|
/** Register a test which will be run when `deno test` is used on the command
|
|
|
|
|
* line and the containing module looks like a test module.
|
|
|
|
|
* `fn` can be async if required. Declared function must have a name.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({ permissions: { read: true } }, function myTestName(): void {
|
|
|
|
|
* assertEquals("hello", "hello");
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* Deno.test({ permissions: { read: false } }, async function myOtherTestName(): Promise<void> {
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello_world.txt");
|
|
|
|
|
* assertEquals(decoder.decode(data), "Hello world");
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Testing
|
feat(test): Add more overloads for "Deno.test" (#12749)
This commit adds 4 more overloads to "Deno.test()" API.
```
// Deno.test(function testName() { });
export function test(fn: (t: TestContext) => void | Promise<void>): void;
// Deno.test("test name", { only: true }, function() { });
export function test(
name: string,
options: Omit<TestDefinition, "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ name: "test name" }, function() { });
export function test(
options: Omit<TestDefinition, "fn">,
fn: (t: TestContext) => void | Promise<void>,
): void;
// Deno.test({ only: true }, function testName() { });
export function test(
options: Omit<TestDefinition, "fn" | "name">,
fn: (t: TestContext) => void | Promise<void>,
): void;
```
2021-11-23 08:57:51 -05:00
|
|
|
|
*/
|
|
|
|
|
export function test(
|
|
|
|
|
options: Omit<TestDefinition, "fn" | "name">,
|
|
|
|
|
fn: (t: TestContext) => void | Promise<void>,
|
|
|
|
|
): void;
|
2022-03-11 17:07:02 -05:00
|
|
|
|
|
2020-03-24 23:54:41 -04:00
|
|
|
|
/** Exit the Deno process with optional exit code. If no exit code is supplied
|
|
|
|
|
* then Deno will exit with return code of 0.
|
|
|
|
|
*
|
2022-06-13 17:53:04 -04:00
|
|
|
|
* In worker contexts this is an alias to `self.close();`.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.exit(5);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
2020-03-24 23:54:41 -04:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function exit(code?: number): never;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-22 20:57:01 -04:00
|
|
|
|
/**
|
|
|
|
|
* @tags allow-env
|
|
|
|
|
* @category Runtime Environment
|
|
|
|
|
*/
|
2020-04-29 14:48:19 -04:00
|
|
|
|
export const env: {
|
2021-05-06 05:45:36 -04:00
|
|
|
|
/** Retrieve the value of an environment variable. Returns `undefined` if that
|
2020-04-29 14:48:19 -04:00
|
|
|
|
* key doesn't exist.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* console.log(Deno.env.get("HOME")); // e.g. outputs "/home/alice"
|
2021-05-06 05:45:36 -04:00
|
|
|
|
* console.log(Deno.env.get("MADE_UP_VAR")); // outputs "undefined"
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* Requires `allow-env` permission.
|
|
|
|
|
*
|
|
|
|
|
* @tags allow-env
|
|
|
|
|
*/
|
2020-04-29 14:48:19 -04:00
|
|
|
|
get(key: string): string | undefined;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-29 14:48:19 -04:00
|
|
|
|
/** Set the value of an environment variable.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2021-05-05 01:57:02 -04:00
|
|
|
|
* Deno.env.set("SOME_VAR", "Value");
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* Deno.env.get("SOME_VAR"); // outputs "Value"
|
|
|
|
|
* ```
|
2020-04-29 14:48:19 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* Requires `allow-env` permission.
|
|
|
|
|
*
|
|
|
|
|
* @tags allow-env
|
|
|
|
|
*/
|
2020-04-29 14:48:19 -04:00
|
|
|
|
set(key: string, value: string): void;
|
|
|
|
|
|
2020-06-09 08:58:30 -04:00
|
|
|
|
/** Delete the value of an environment variable.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2021-05-05 01:57:02 -04:00
|
|
|
|
* Deno.env.set("SOME_VAR", "Value");
|
2021-05-06 05:45:36 -04:00
|
|
|
|
* Deno.env.delete("SOME_VAR"); // outputs "undefined"
|
2020-06-09 08:58:30 -04:00
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* Requires `allow-env` permission.
|
|
|
|
|
*
|
|
|
|
|
* @tags allow-env
|
|
|
|
|
*/
|
2020-06-09 08:58:30 -04:00
|
|
|
|
delete(key: string): void;
|
|
|
|
|
|
2020-04-29 14:48:19 -04:00
|
|
|
|
/** Returns a snapshot of the environment variables at invocation.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.env.set("TEST_VAR", "A");
|
|
|
|
|
* const myEnv = Deno.env.toObject();
|
|
|
|
|
* console.log(myEnv.SHELL);
|
|
|
|
|
* Deno.env.set("TEST_VAR", "B");
|
|
|
|
|
* console.log(myEnv.TEST_VAR); // outputs "A"
|
|
|
|
|
* ```
|
2020-04-29 14:48:19 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* Requires `allow-env` permission.
|
|
|
|
|
*
|
|
|
|
|
* @tags allow-env
|
|
|
|
|
*/
|
2020-04-29 14:48:19 -04:00
|
|
|
|
toObject(): { [index: string]: string };
|
|
|
|
|
};
|
2019-12-18 09:29:00 -05:00
|
|
|
|
|
2019-08-30 11:11:33 -04:00
|
|
|
|
/**
|
|
|
|
|
* Returns the path to the current deno executable.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* console.log(Deno.execPath()); // e.g. "/home/alice/.local/bin/deno"
|
|
|
|
|
* ```
|
2020-03-24 23:54:41 -04:00
|
|
|
|
*
|
2020-05-06 15:51:33 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category Runtime Environment
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
|
|
|
|
export function execPath(): string;
|
|
|
|
|
|
|
|
|
|
/**
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Change the current working directory to the specified path.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.chdir("/home/userA");
|
|
|
|
|
* Deno.chdir("../userB");
|
|
|
|
|
* Deno.chdir("C:\\Program Files (x86)\\Java");
|
|
|
|
|
* ```
|
2020-03-18 19:40:06 -04:00
|
|
|
|
*
|
|
|
|
|
* Throws `Deno.errors.NotFound` if directory not found.
|
|
|
|
|
* Throws `Deno.errors.PermissionDenied` if the user does not have access
|
|
|
|
|
* rights
|
2020-04-24 19:55:33 -04:00
|
|
|
|
*
|
2020-05-02 18:33:43 -04:00
|
|
|
|
* Requires --allow-read.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category Runtime Environment
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2021-06-03 10:32:18 -04:00
|
|
|
|
export function chdir(directory: string | URL): void;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-05-04 14:23:06 -04:00
|
|
|
|
/**
|
|
|
|
|
* Return a string representing the current working directory.
|
|
|
|
|
*
|
|
|
|
|
* If the current directory can be reached via multiple paths (due to symbolic
|
|
|
|
|
* links), `cwd()` may return any one of them.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const currentWorkingDirectory = Deno.cwd();
|
|
|
|
|
* ```
|
2020-05-04 14:23:06 -04:00
|
|
|
|
*
|
|
|
|
|
* Throws `Deno.errors.NotFound` if directory not available.
|
|
|
|
|
*
|
|
|
|
|
* Requires --allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category Runtime Environment
|
2020-05-04 14:23:06 -04:00
|
|
|
|
*/
|
|
|
|
|
export function cwd(): string;
|
|
|
|
|
|
2021-02-25 12:35:10 -05:00
|
|
|
|
/**
|
|
|
|
|
* Synchronously creates `newpath` as a hard link to `oldpath`.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.linkSync("old/name", "new/name");
|
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` and `allow-write` permissions.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-02-25 12:35:10 -05:00
|
|
|
|
export function linkSync(oldpath: string, newpath: string): void;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates `newpath` as a hard link to `oldpath`.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.link("old/name", "new/name");
|
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` and `allow-write` permissions.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-02-25 12:35:10 -05:00
|
|
|
|
export function link(oldpath: string, newpath: string): Promise<void>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export enum SeekMode {
|
2020-04-28 06:30:59 -04:00
|
|
|
|
Start = 0,
|
|
|
|
|
Current = 1,
|
|
|
|
|
End = 2,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export interface Reader {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
|
|
|
|
|
* bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
|
|
|
|
|
* encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
|
|
|
|
|
* use all of `p` as scratch space during the call. If some data is
|
|
|
|
|
* available but not `p.byteLength` bytes, `read()` conventionally resolves
|
|
|
|
|
* to what is available instead of waiting for more.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* When `read()` encounters end-of-file condition, it resolves to EOF
|
|
|
|
|
* (`null`).
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
|
|
|
|
* When `read()` encounters an error, it rejects with an error.
|
|
|
|
|
*
|
|
|
|
|
* Callers should always process the `n` > `0` bytes returned before
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* considering the EOF (`null`). Doing so correctly handles I/O errors that
|
|
|
|
|
* happen after reading some bytes and also both of the allowed EOF
|
|
|
|
|
* behaviors.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Implementations should not retain a reference to `p`.
|
2020-04-22 16:00:48 -04:00
|
|
|
|
*
|
2022-05-30 10:42:31 -04:00
|
|
|
|
* Use `itereateReader` from from https://deno.land/std/streams/conversion.ts to
|
|
|
|
|
* turn a Reader into an AsyncIterator.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-28 12:40:43 -04:00
|
|
|
|
read(p: Uint8Array): Promise<number | null>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2020-04-28 07:23:30 -04:00
|
|
|
|
export interface ReaderSync {
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
|
|
|
|
|
* of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
|
2021-05-21 10:00:16 -04:00
|
|
|
|
* encountered. Even if `readSync()` returns `n` < `p.byteLength`, it may use
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* all of `p` as scratch space during the call. If some data is available
|
2021-05-21 10:00:16 -04:00
|
|
|
|
* but not `p.byteLength` bytes, `readSync()` conventionally returns what is
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* available instead of waiting for more.
|
|
|
|
|
*
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* When `readSync()` encounters end-of-file condition, it returns EOF
|
|
|
|
|
* (`null`).
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
|
|
|
|
* When `readSync()` encounters an error, it throws with an error.
|
|
|
|
|
*
|
|
|
|
|
* Callers should always process the `n` > `0` bytes returned before
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* considering the EOF (`null`). Doing so correctly handles I/O errors that happen
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* after reading some bytes and also both of the allowed EOF behaviors.
|
|
|
|
|
*
|
|
|
|
|
* Implementations should not retain a reference to `p`.
|
2020-04-22 16:00:48 -04:00
|
|
|
|
*
|
2022-05-30 10:42:31 -04:00
|
|
|
|
* Use `iterateReaderSync()` from from https://deno.land/std/streams/conversion.ts
|
|
|
|
|
* to turn a ReaderSync into an Iterator.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*/
|
2020-04-28 12:40:43 -04:00
|
|
|
|
readSync(p: Uint8Array): number | null;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export interface Writer {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
|
|
|
|
|
* resolves to the number of bytes written from `p` (`0` <= `n` <=
|
|
|
|
|
* `p.byteLength`) or reject with the error encountered that caused the
|
|
|
|
|
* write to stop early. `write()` must reject with a non-null error if
|
|
|
|
|
* would resolve to `n` < `p.byteLength`. `write()` must not modify the
|
|
|
|
|
* slice data, even temporarily.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Implementations should not retain a reference to `p`.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
|
|
|
|
write(p: Uint8Array): Promise<number>;
|
|
|
|
|
}
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2020-04-28 07:23:30 -04:00
|
|
|
|
export interface WriterSync {
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Writes `p.byteLength` bytes from `p` to the underlying data
|
|
|
|
|
* stream. It returns the number of bytes written from `p` (`0` <= `n`
|
|
|
|
|
* <= `p.byteLength`) and any error encountered that caused the write to
|
|
|
|
|
* stop early. `writeSync()` must throw a non-null error if it returns `n` <
|
|
|
|
|
* `p.byteLength`. `writeSync()` must not modify the slice data, even
|
|
|
|
|
* temporarily.
|
|
|
|
|
*
|
|
|
|
|
* Implementations should not retain a reference to `p`.
|
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
writeSync(p: Uint8Array): number;
|
|
|
|
|
}
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export interface Closer {
|
|
|
|
|
close(): void;
|
|
|
|
|
}
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export interface Seeker {
|
|
|
|
|
/** Seek sets the offset for the next `read()` or `write()` to offset,
|
2020-04-28 06:30:59 -04:00
|
|
|
|
* interpreted according to `whence`: `Start` means relative to the
|
|
|
|
|
* start of the file, `Current` means relative to the current offset,
|
|
|
|
|
* and `End` means relative to the end. Seek resolves to the new offset
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* relative to the start of the file.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
|
|
|
|
* Seeking to an offset before the start of the file is an error. Seeking to
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* any positive offset is legal, but the behavior of subsequent I/O
|
|
|
|
|
* operations on the underlying object is implementation-dependent.
|
2020-03-02 11:44:46 -05:00
|
|
|
|
* It returns the number of cursor position.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-03-02 11:44:46 -05:00
|
|
|
|
seek(offset: number, whence: SeekMode): Promise<number>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category I/O */
|
2020-04-28 07:23:30 -04:00
|
|
|
|
export interface SeekerSync {
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Seek sets the offset for the next `readSync()` or `writeSync()` to
|
2020-04-28 06:30:59 -04:00
|
|
|
|
* offset, interpreted according to `whence`: `Start` means relative
|
|
|
|
|
* to the start of the file, `Current` means relative to the current
|
|
|
|
|
* offset, and `End` means relative to the end.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
|
|
|
|
* Seeking to an offset before the start of the file is an error. Seeking to
|
|
|
|
|
* any positive offset is legal, but the behavior of subsequent I/O
|
|
|
|
|
* operations on the underlying object is implementation-dependent.
|
|
|
|
|
*/
|
2020-03-02 11:44:46 -05:00
|
|
|
|
seekSync(offset: number, whence: SeekMode): number;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2021-07-12 13:44:42 -04:00
|
|
|
|
/**
|
|
|
|
|
* Copies from `src` to `dst` until either EOF (`null`) is read from `src` or
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* an error occurs. It resolves to the number of bytes copied or rejects with
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* the first error encountered while copying.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const source = await Deno.open("my_file.txt");
|
|
|
|
|
* const bytesCopied1 = await Deno.copy(source, Deno.stdout);
|
2021-04-05 18:05:36 -04:00
|
|
|
|
* const destination = await Deno.create("my_file_2.txt");
|
|
|
|
|
* const bytesCopied2 = await Deno.copy(source, destination);
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```
|
2020-03-24 23:54:41 -04:00
|
|
|
|
*
|
2021-12-09 19:05:50 -05:00
|
|
|
|
* @deprecated Use `copy` from https://deno.land/std/streams/conversion.ts
|
|
|
|
|
* instead. `Deno.copy` will be removed in Deno 2.0.
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category I/O
|
|
|
|
|
*
|
2020-03-24 23:54:41 -04:00
|
|
|
|
* @param src The source to copy from
|
2020-04-24 18:09:14 -04:00
|
|
|
|
* @param dst The destination to copy to
|
2020-04-26 16:25:24 -04:00
|
|
|
|
* @param options Can be used to tune size of the buffer. Default size is 32kB
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-26 16:25:24 -04:00
|
|
|
|
export function copy(
|
|
|
|
|
src: Reader,
|
|
|
|
|
dst: Writer,
|
|
|
|
|
options?: {
|
|
|
|
|
bufSize?: number;
|
2020-07-14 15:24:17 -04:00
|
|
|
|
},
|
2020-04-26 16:25:24 -04:00
|
|
|
|
): Promise<number>;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2021-04-05 18:05:55 -04:00
|
|
|
|
/**
|
|
|
|
|
* Turns a Reader, `r`, into an async iterator.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* let f = await Deno.open("/etc/passwd");
|
|
|
|
|
* for await (const chunk of Deno.iter(f)) {
|
|
|
|
|
* console.log(chunk);
|
|
|
|
|
* }
|
|
|
|
|
* f.close();
|
|
|
|
|
* ```
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
|
|
|
|
* Second argument can be used to tune size of a buffer.
|
2020-04-24 18:05:48 -04:00
|
|
|
|
* Default size of the buffer is 32kB.
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* let f = await Deno.open("/etc/passwd");
|
|
|
|
|
* const iter = Deno.iter(f, {
|
|
|
|
|
* bufSize: 1024 * 1024
|
|
|
|
|
* });
|
|
|
|
|
* for await (const chunk of iter) {
|
|
|
|
|
* console.log(chunk);
|
|
|
|
|
* }
|
|
|
|
|
* f.close();
|
|
|
|
|
* ```
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
2020-04-24 18:05:48 -04:00
|
|
|
|
* Iterator uses an internal buffer of fixed size for efficiency; it returns
|
|
|
|
|
* a view on that buffer on each iteration. It is therefore caller's
|
|
|
|
|
* responsibility to copy contents of the buffer if needed; otherwise the
|
2020-04-22 15:30:45 -04:00
|
|
|
|
* next iteration will overwrite contents of previously returned chunk.
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `iterateReader` from
|
|
|
|
|
* https://deno.land/std/streams/conversion.ts instead. `Deno.iter` will be
|
|
|
|
|
* removed in Deno 2.0.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*/
|
|
|
|
|
export function iter(
|
|
|
|
|
r: Reader,
|
2020-04-24 18:05:48 -04:00
|
|
|
|
options?: {
|
|
|
|
|
bufSize?: number;
|
2020-07-14 15:24:17 -04:00
|
|
|
|
},
|
2020-04-22 15:30:45 -04:00
|
|
|
|
): AsyncIterableIterator<Uint8Array>;
|
|
|
|
|
|
2021-04-05 18:05:55 -04:00
|
|
|
|
/**
|
|
|
|
|
* Turns a ReaderSync, `r`, into an iterator.
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* let f = Deno.openSync("/etc/passwd");
|
2020-06-01 09:53:43 -04:00
|
|
|
|
* for (const chunk of Deno.iterSync(f)) {
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* console.log(chunk);
|
|
|
|
|
* }
|
|
|
|
|
* f.close();
|
|
|
|
|
* ```
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
|
|
|
|
* Second argument can be used to tune size of a buffer.
|
2020-04-24 18:05:48 -04:00
|
|
|
|
* Default size of the buffer is 32kB.
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* let f = await Deno.open("/etc/passwd");
|
|
|
|
|
* const iter = Deno.iterSync(f, {
|
|
|
|
|
* bufSize: 1024 * 1024
|
|
|
|
|
* });
|
|
|
|
|
* for (const chunk of iter) {
|
|
|
|
|
* console.log(chunk);
|
|
|
|
|
* }
|
|
|
|
|
* f.close();
|
|
|
|
|
* ```
|
2020-04-22 15:30:45 -04:00
|
|
|
|
*
|
2020-04-24 18:05:48 -04:00
|
|
|
|
* Iterator uses an internal buffer of fixed size for efficiency; it returns
|
|
|
|
|
* a view on that buffer on each iteration. It is therefore caller's
|
|
|
|
|
* responsibility to copy contents of the buffer if needed; otherwise the
|
2020-04-22 15:30:45 -04:00
|
|
|
|
* next iteration will overwrite contents of previously returned chunk.
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `iterateReaderSync` from
|
|
|
|
|
* https://deno.land/std/streams/conversion.ts instead. `Deno.iterSync` will
|
|
|
|
|
* be removed in Deno 2.0.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-22 15:30:45 -04:00
|
|
|
|
export function iterSync(
|
2020-04-28 07:23:30 -04:00
|
|
|
|
r: ReaderSync,
|
2020-04-24 18:05:48 -04:00
|
|
|
|
options?: {
|
|
|
|
|
bufSize?: number;
|
2020-07-14 15:24:17 -04:00
|
|
|
|
},
|
2020-04-22 15:30:45 -04:00
|
|
|
|
): IterableIterator<Uint8Array>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2022-02-15 07:59:04 -05:00
|
|
|
|
/** Synchronously open a file and return an instance of `Deno.FsFile`. The
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* file does not need to previously exist if using the `create` or `createNew`
|
|
|
|
|
* open options. It is the callers responsibility to close the file when finished
|
|
|
|
|
* with it.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = Deno.openSync("/foo/bar.txt", { read: true, write: true });
|
|
|
|
|
* // Do work with file
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
* ```
|
2020-01-21 04:49:42 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* Requires `allow-read` and/or `allow-write` permissions depending on options.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-01-21 04:49:42 -05:00
|
|
|
|
*/
|
2022-02-15 07:59:04 -05:00
|
|
|
|
export function openSync(path: string | URL, options?: OpenOptions): FsFile;
|
2020-01-21 04:49:42 -05:00
|
|
|
|
|
2022-02-15 07:59:04 -05:00
|
|
|
|
/** Open a file and resolve to an instance of `Deno.FsFile`. The
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* file does not need to previously exist if using the `create` or `createNew`
|
|
|
|
|
* open options. It is the callers responsibility to close the file when finished
|
|
|
|
|
* with it.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = await Deno.open("/foo/bar.txt", { read: true, write: true });
|
|
|
|
|
* // Do work with file
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
* ```
|
2020-01-21 04:49:42 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* Requires `allow-read` and/or `allow-write` permissions depending on options.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-01-21 04:49:42 -05:00
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function open(
|
|
|
|
|
path: string | URL,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: OpenOptions,
|
2022-02-15 07:59:04 -05:00
|
|
|
|
): Promise<FsFile>;
|
2020-01-21 04:49:42 -05:00
|
|
|
|
|
2020-01-08 17:07:03 -05:00
|
|
|
|
/** Creates a file if none exists or truncates an existing file and returns
|
2022-02-15 07:59:04 -05:00
|
|
|
|
* an instance of `Deno.FsFile`.
|
2020-01-08 17:07:03 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = Deno.createSync("/foo/bar.txt");
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Requires `allow-read` and `allow-write` permissions.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-01-08 17:07:03 -05:00
|
|
|
|
*/
|
2022-02-15 07:59:04 -05:00
|
|
|
|
export function createSync(path: string | URL): FsFile;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Creates a file if none exists or truncates an existing file and resolves to
|
2022-02-15 07:59:04 -05:00
|
|
|
|
* an instance of `Deno.FsFile`.
|
2020-01-08 17:07:03 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = await Deno.create("/foo/bar.txt");
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Requires `allow-read` and `allow-write` permissions.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-01-08 17:07:03 -05:00
|
|
|
|
*/
|
2022-02-15 07:59:04 -05:00
|
|
|
|
export function create(path: string | URL): Promise<FsFile>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-01 12:57:33 -04:00
|
|
|
|
/** Synchronously read from a resource ID (`rid`) into an array buffer (`buffer`).
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* Returns either the number of bytes read during the operation or EOF
|
|
|
|
|
* (`null`) if there was nothing more to read.
|
|
|
|
|
*
|
|
|
|
|
* It is possible for a read to successfully return with `0` bytes. This does
|
|
|
|
|
* not indicate EOF.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-22 12:56:12 -04:00
|
|
|
|
* This function is one of the lowest level APIs and most users should not
|
2022-05-30 10:42:31 -04:00
|
|
|
|
* work with this directly, but rather use
|
|
|
|
|
* `readAllSync()` from https://deno.land/std/streams/conversion.ts instead.
|
2020-05-22 12:56:12 -04:00
|
|
|
|
*
|
|
|
|
|
* **It is not guaranteed that the full buffer will be read in a single call.**
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // if "/foo/bar.txt" contains the text "hello world":
|
|
|
|
|
* const file = Deno.openSync("/foo/bar.txt");
|
|
|
|
|
* const buf = new Uint8Array(100);
|
|
|
|
|
* const numberOfBytesRead = Deno.readSync(file.rid, buf); // 11 bytes
|
|
|
|
|
* const text = new TextDecoder().decode(buf); // "hello world"
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-28 12:40:43 -04:00
|
|
|
|
export function readSync(rid: number, buffer: Uint8Array): number | null;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-01 12:57:33 -04:00
|
|
|
|
/** Read from a resource ID (`rid`) into an array buffer (`buffer`).
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* Resolves to either the number of bytes read during the operation or EOF
|
|
|
|
|
* (`null`) if there was nothing more to read.
|
|
|
|
|
*
|
|
|
|
|
* It is possible for a read to successfully return with `0` bytes. This does
|
|
|
|
|
* not indicate EOF.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-22 12:56:12 -04:00
|
|
|
|
* This function is one of the lowest level APIs and most users should not
|
2022-05-30 10:42:31 -04:00
|
|
|
|
* work with this directly, but rather use
|
|
|
|
|
* `readAll()` from https://deno.land/std/streams/conversion.ts instead.
|
2020-05-22 12:56:12 -04:00
|
|
|
|
*
|
|
|
|
|
* **It is not guaranteed that the full buffer will be read in a single call.**
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // if "/foo/bar.txt" contains the text "hello world":
|
|
|
|
|
* const file = await Deno.open("/foo/bar.txt");
|
|
|
|
|
* const buf = new Uint8Array(100);
|
|
|
|
|
* const numberOfBytesRead = await Deno.read(file.rid, buf); // 11 bytes
|
|
|
|
|
* const text = new TextDecoder().decode(buf); // "hello world"
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-28 12:40:43 -04:00
|
|
|
|
export function read(rid: number, buffer: Uint8Array): Promise<number | null>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-01 12:57:33 -04:00
|
|
|
|
/** Synchronously write to the resource ID (`rid`) the contents of the array
|
|
|
|
|
* buffer (`data`).
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-22 12:56:12 -04:00
|
|
|
|
* Returns the number of bytes written. This function is one of the lowest
|
|
|
|
|
* level APIs and most users should not work with this directly, but rather use
|
2022-01-10 09:22:41 -05:00
|
|
|
|
* `writeAllSync()` from https://deno.land/std/streams/conversion.ts instead.
|
2020-05-22 12:56:12 -04:00
|
|
|
|
*
|
|
|
|
|
* **It is not guaranteed that the full buffer will be written in a single
|
|
|
|
|
* call.**
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const encoder = new TextEncoder();
|
|
|
|
|
* const data = encoder.encode("Hello world");
|
2020-06-01 09:53:43 -04:00
|
|
|
|
* const file = Deno.openSync("/foo/bar.txt", {write: true});
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const bytesWritten = Deno.writeSync(file.rid, data); // 11
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-01 12:57:33 -04:00
|
|
|
|
export function writeSync(rid: number, data: Uint8Array): number;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-01 12:57:33 -04:00
|
|
|
|
/** Write to the resource ID (`rid`) the contents of the array buffer (`data`).
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-22 12:56:12 -04:00
|
|
|
|
* Resolves to the number of bytes written. This function is one of the lowest
|
|
|
|
|
* level APIs and most users should not work with this directly, but rather use
|
2022-05-30 10:42:31 -04:00
|
|
|
|
* `writeAll()` from https://deno.land/std/streams/conversion.ts instead.
|
2020-05-22 12:56:12 -04:00
|
|
|
|
*
|
|
|
|
|
* **It is not guaranteed that the full buffer will be written in a single
|
|
|
|
|
* call.**
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const encoder = new TextEncoder();
|
|
|
|
|
* const data = encoder.encode("Hello world");
|
2020-06-01 09:53:43 -04:00
|
|
|
|
* const file = await Deno.open("/foo/bar.txt", { write: true });
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const bytesWritten = await Deno.write(file.rid, data); // 11
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-04-01 12:57:33 -04:00
|
|
|
|
export function write(rid: number, data: Uint8Array): Promise<number>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Synchronously seek a resource ID (`rid`) to the given `offset` under mode
|
2020-04-03 13:45:44 -04:00
|
|
|
|
* given by `whence`. The new position within the resource (bytes from the
|
|
|
|
|
* start) is returned.
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = Deno.openSync('hello.txt', {read: true, write: true, truncate: true, create: true});
|
|
|
|
|
* Deno.writeSync(file.rid, new TextEncoder().encode("Hello world"));
|
2021-05-10 22:13:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // advance cursor 6 bytes
|
|
|
|
|
* const cursorPosition = Deno.seekSync(file.rid, 6, Deno.SeekMode.Start);
|
|
|
|
|
* console.log(cursorPosition); // 6
|
|
|
|
|
* const buf = new Uint8Array(100);
|
|
|
|
|
* file.readSync(buf);
|
|
|
|
|
* console.log(new TextDecoder().decode(buf)); // "world"
|
|
|
|
|
* ```
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
|
|
|
|
* The seek modes work as follows:
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
|
2021-05-10 22:13:33 -04:00
|
|
|
|
* const file = Deno.openSync('hello.txt', {read: true, write: true, truncate: true, create: true});
|
|
|
|
|
* Deno.writeSync(file.rid, new TextEncoder().encode("Hello world"));
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // Seek 6 bytes from the start of the file
|
|
|
|
|
* console.log(Deno.seekSync(file.rid, 6, Deno.SeekMode.Start)); // "6"
|
|
|
|
|
* // Seek 2 more bytes from the current position
|
|
|
|
|
* console.log(Deno.seekSync(file.rid, 2, Deno.SeekMode.Current)); // "8"
|
|
|
|
|
* // Seek backwards 2 bytes from the end of the file
|
|
|
|
|
* console.log(Deno.seekSync(file.rid, -2, Deno.SeekMode.End)); // "9" (e.g. 11-2)
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-03-02 11:44:46 -05:00
|
|
|
|
export function seekSync(
|
|
|
|
|
rid: number,
|
|
|
|
|
offset: number,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
whence: SeekMode,
|
2020-03-02 11:44:46 -05:00
|
|
|
|
): number;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Seek a resource ID (`rid`) to the given `offset` under mode given by `whence`.
|
2020-04-03 13:45:44 -04:00
|
|
|
|
* The call resolves to the new position within the resource (bytes from the start).
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2021-05-10 22:13:33 -04:00
|
|
|
|
* // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const file = await Deno.open('hello.txt', {read: true, write: true, truncate: true, create: true});
|
|
|
|
|
* await Deno.write(file.rid, new TextEncoder().encode("Hello world"));
|
2021-05-10 22:13:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // advance cursor 6 bytes
|
|
|
|
|
* const cursorPosition = await Deno.seek(file.rid, 6, Deno.SeekMode.Start);
|
|
|
|
|
* console.log(cursorPosition); // 6
|
|
|
|
|
* const buf = new Uint8Array(100);
|
|
|
|
|
* await file.read(buf);
|
|
|
|
|
* console.log(new TextDecoder().decode(buf)); // "world"
|
|
|
|
|
* ```
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
|
|
|
|
* The seek modes work as follows:
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
|
2021-05-10 22:13:33 -04:00
|
|
|
|
* const file = await Deno.open('hello.txt', {read: true, write: true, truncate: true, create: true});
|
|
|
|
|
* await Deno.write(file.rid, new TextEncoder().encode("Hello world"));
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // Seek 6 bytes from the start of the file
|
|
|
|
|
* console.log(await Deno.seek(file.rid, 6, Deno.SeekMode.Start)); // "6"
|
|
|
|
|
* // Seek 2 more bytes from the current position
|
|
|
|
|
* console.log(await Deno.seek(file.rid, 2, Deno.SeekMode.Current)); // "8"
|
|
|
|
|
* // Seek backwards 2 bytes from the end of the file
|
|
|
|
|
* console.log(await Deno.seek(file.rid, -2, Deno.SeekMode.End)); // "9" (e.g. 11-2)
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
|
|
|
|
export function seek(
|
|
|
|
|
rid: number,
|
|
|
|
|
offset: number,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
whence: SeekMode,
|
2020-03-02 11:44:46 -05:00
|
|
|
|
): Promise<number>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-10-20 09:52:10 -04:00
|
|
|
|
/**
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Synchronously flushes any pending data and metadata operations of the given
|
|
|
|
|
* file stream to disk.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2020-10-20 09:52:10 -04:00
|
|
|
|
* const file = Deno.openSync("my_file.txt", { read: true, write: true, create: true });
|
|
|
|
|
* Deno.writeSync(file.rid, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* Deno.ftruncateSync(file.rid, 1);
|
|
|
|
|
* Deno.fsyncSync(file.rid);
|
|
|
|
|
* console.log(new TextDecoder().decode(Deno.readFileSync("my_file.txt"))); // H
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-10-20 09:52:10 -04:00
|
|
|
|
*/
|
|
|
|
|
export function fsyncSync(rid: number): void;
|
|
|
|
|
|
|
|
|
|
/**
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Flushes any pending data and metadata operations of the given file stream
|
|
|
|
|
* to disk.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2020-10-20 09:52:10 -04:00
|
|
|
|
* const file = await Deno.open("my_file.txt", { read: true, write: true, create: true });
|
|
|
|
|
* await Deno.write(file.rid, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* await Deno.ftruncate(file.rid, 1);
|
|
|
|
|
* await Deno.fsync(file.rid);
|
|
|
|
|
* console.log(new TextDecoder().decode(await Deno.readFile("my_file.txt"))); // H
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-10-20 09:52:10 -04:00
|
|
|
|
*/
|
|
|
|
|
export function fsync(rid: number): Promise<void>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/**
|
|
|
|
|
* Synchronously flushes any pending data operations of the given file stream
|
|
|
|
|
* to disk.
|
|
|
|
|
*
|
2020-10-20 09:52:10 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = Deno.openSync("my_file.txt", { read: true, write: true, create: true });
|
|
|
|
|
* Deno.writeSync(file.rid, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* Deno.fdatasyncSync(file.rid);
|
|
|
|
|
* console.log(new TextDecoder().decode(Deno.readFileSync("my_file.txt"))); // Hello World
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-10-20 09:52:10 -04:00
|
|
|
|
*/
|
|
|
|
|
export function fdatasyncSync(rid: number): void;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Flushes any pending data operations of the given file stream to disk.
|
|
|
|
|
* ```ts
|
|
|
|
|
* const file = await Deno.open("my_file.txt", { read: true, write: true, create: true });
|
|
|
|
|
* await Deno.write(file.rid, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* await Deno.fdatasync(file.rid);
|
|
|
|
|
* console.log(new TextDecoder().decode(await Deno.readFile("my_file.txt"))); // Hello World
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-10-20 09:52:10 -04:00
|
|
|
|
*/
|
|
|
|
|
export function fdatasync(rid: number): Promise<void>;
|
|
|
|
|
|
2020-03-23 00:03:45 -04:00
|
|
|
|
/** Close the given resource ID (rid) which has been previously opened, such
|
|
|
|
|
* as via opening or creating a file. Closing a file when you are finished
|
|
|
|
|
* with it is important to avoid leaking resources.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const file = await Deno.open("my_file.txt");
|
|
|
|
|
* // do work with "file" object
|
|
|
|
|
* Deno.close(file.rid);
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-03-23 00:03:45 -04:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function close(rid: number): void;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** The Deno abstraction for reading and writing files.
|
|
|
|
|
*
|
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2022-02-15 07:59:04 -05:00
|
|
|
|
export class FsFile
|
|
|
|
|
implements
|
|
|
|
|
Reader,
|
|
|
|
|
ReaderSync,
|
|
|
|
|
Writer,
|
|
|
|
|
WriterSync,
|
|
|
|
|
Seeker,
|
|
|
|
|
SeekerSync,
|
|
|
|
|
Closer {
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
constructor(rid: number);
|
|
|
|
|
write(p: Uint8Array): Promise<number>;
|
|
|
|
|
writeSync(p: Uint8Array): number;
|
|
|
|
|
truncate(len?: number): Promise<void>;
|
|
|
|
|
truncateSync(len?: number): void;
|
|
|
|
|
read(p: Uint8Array): Promise<number | null>;
|
|
|
|
|
readSync(p: Uint8Array): number | null;
|
|
|
|
|
seek(offset: number, whence: SeekMode): Promise<number>;
|
|
|
|
|
seekSync(offset: number, whence: SeekMode): number;
|
|
|
|
|
stat(): Promise<FileInfo>;
|
|
|
|
|
statSync(): FileInfo;
|
|
|
|
|
close(): void;
|
2022-02-15 08:38:39 -05:00
|
|
|
|
|
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
|
|
|
readonly writable: WritableStream<Uint8Array>;
|
2022-02-15 07:59:04 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The Deno abstraction for reading and writing files.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `Deno.FsFile` instead. `Deno.File` will be removed in Deno 2.0.
|
|
|
|
|
* @category File System
|
2022-02-15 07:59:04 -05:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export class File
|
|
|
|
|
implements
|
|
|
|
|
Reader,
|
2020-04-28 07:23:30 -04:00
|
|
|
|
ReaderSync,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
Writer,
|
2020-04-28 07:23:30 -04:00
|
|
|
|
WriterSync,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
Seeker,
|
2020-04-28 07:23:30 -04:00
|
|
|
|
SeekerSync,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
Closer {
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
constructor(rid: number);
|
|
|
|
|
write(p: Uint8Array): Promise<number>;
|
|
|
|
|
writeSync(p: Uint8Array): number;
|
2021-04-26 10:56:22 -04:00
|
|
|
|
truncate(len?: number): Promise<void>;
|
|
|
|
|
truncateSync(len?: number): void;
|
2020-04-28 12:40:43 -04:00
|
|
|
|
read(p: Uint8Array): Promise<number | null>;
|
|
|
|
|
readSync(p: Uint8Array): number | null;
|
2020-03-02 11:44:46 -05:00
|
|
|
|
seek(offset: number, whence: SeekMode): Promise<number>;
|
|
|
|
|
seekSync(offset: number, whence: SeekMode): number;
|
2021-04-12 07:33:05 -04:00
|
|
|
|
stat(): Promise<FileInfo>;
|
|
|
|
|
statSync(): FileInfo;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
close(): void;
|
2022-02-15 07:35:22 -05:00
|
|
|
|
|
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
|
|
|
readonly writable: WritableStream<Uint8Array>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-02-26 01:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** A handle for `stdin`.
|
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
|
|
|
|
*/
|
2022-02-15 07:35:22 -05:00
|
|
|
|
export const stdin: Reader & ReaderSync & Closer & {
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
readonly readable: ReadableStream<Uint8Array>;
|
|
|
|
|
};
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** A handle for `stdout`.
|
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
|
|
|
|
*/
|
2022-02-15 07:35:22 -05:00
|
|
|
|
export const stdout: Writer & WriterSync & Closer & {
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
readonly writable: WritableStream<Uint8Array>;
|
|
|
|
|
};
|
2020-04-24 19:01:25 -04:00
|
|
|
|
/** A handle for `stderr`. */
|
2022-02-15 07:35:22 -05:00
|
|
|
|
export const stderr: Writer & WriterSync & Closer & {
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
readonly writable: WritableStream<Uint8Array>;
|
|
|
|
|
};
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2020-01-21 04:49:42 -05:00
|
|
|
|
export interface OpenOptions {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Sets the option for read access. This option, when `true`, means that the
|
|
|
|
|
* file should be read-able if opened. */
|
2020-01-21 04:49:42 -05:00
|
|
|
|
read?: boolean;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Sets the option for write access. This option, when `true`, means that
|
|
|
|
|
* the file should be write-able if opened. If the file already exists,
|
|
|
|
|
* any write calls on it will overwrite its contents, by default without
|
|
|
|
|
* truncating it. */
|
2020-01-21 04:49:42 -05:00
|
|
|
|
write?: boolean;
|
2021-09-02 18:28:12 -04:00
|
|
|
|
/** Sets the option for the append mode. This option, when `true`, means that
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* writes will append to a file instead of overwriting previous contents.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Note that setting `{ write: true, append: true }` has the same effect as
|
|
|
|
|
* setting only `{ append: true }`. */
|
2020-01-21 04:49:42 -05:00
|
|
|
|
append?: boolean;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Sets the option for truncating a previous file. If a file is
|
|
|
|
|
* successfully opened with this option set it will truncate the file to `0`
|
2020-03-14 22:57:42 -04:00
|
|
|
|
* size if it already exists. The file must be opened with write access
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* for truncate to work. */
|
|
|
|
|
truncate?: boolean;
|
|
|
|
|
/** Sets the option to allow creating a new file, if one doesn't already
|
|
|
|
|
* exist at the specified path. Requires write or append access to be
|
|
|
|
|
* used. */
|
|
|
|
|
create?: boolean;
|
|
|
|
|
/** Defaults to `false`. If set to `true`, no file, directory, or symlink is
|
|
|
|
|
* allowed to exist at the target location. Requires write or append
|
|
|
|
|
* access to be used. When createNew is set to `true`, create and truncate
|
|
|
|
|
* are ignored. */
|
2020-01-21 04:49:42 -05:00
|
|
|
|
createNew?: boolean;
|
2020-03-16 15:02:41 -04:00
|
|
|
|
/** Permissions to use if creating the file (defaults to `0o666`, before
|
|
|
|
|
* the process's umask).
|
|
|
|
|
* Ignored on Windows. */
|
|
|
|
|
mode?: number;
|
2020-01-21 04:49:42 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2021-06-22 11:45:26 -04:00
|
|
|
|
export interface ReadFileOptions {
|
|
|
|
|
/**
|
|
|
|
|
* An abort signal to allow cancellation of the file read operation.
|
|
|
|
|
* If the signal becomes aborted the readFile operation will be stopped
|
|
|
|
|
* and the promise returned will be rejected with an AbortError.
|
|
|
|
|
*/
|
|
|
|
|
signal?: AbortSignal;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-29 06:43:34 -04:00
|
|
|
|
/**
|
2020-03-26 15:52:47 -04:00
|
|
|
|
* Check if a given resource id (`rid`) is a TTY.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // This example is system and context specific
|
|
|
|
|
* const nonTTYRid = Deno.openSync("my_file.txt").rid;
|
|
|
|
|
* const ttyRid = Deno.openSync("/dev/tty6").rid;
|
|
|
|
|
* console.log(Deno.isatty(nonTTYRid)); // false
|
|
|
|
|
* console.log(Deno.isatty(ttyRid)); // true
|
|
|
|
|
* Deno.close(nonTTYRid);
|
|
|
|
|
* Deno.close(ttyRid);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-03-26 15:52:47 -04:00
|
|
|
|
*/
|
2020-02-26 01:01:24 -05:00
|
|
|
|
export function isatty(rid: number): boolean;
|
|
|
|
|
|
2021-04-05 18:05:36 -04:00
|
|
|
|
/**
|
|
|
|
|
* A variable-sized buffer of bytes with `read()` and `write()` methods.
|
2020-04-22 14:26:16 -04:00
|
|
|
|
*
|
|
|
|
|
* Deno.Buffer is almost always used with some I/O like files and sockets. It
|
|
|
|
|
* allows one to buffer up a download from a socket. Buffer grows and shrinks
|
|
|
|
|
* as necessary.
|
|
|
|
|
*
|
|
|
|
|
* Deno.Buffer is NOT the same thing as Node's Buffer. Node's Buffer was
|
|
|
|
|
* created in 2009 before JavaScript had the concept of ArrayBuffers. It's
|
|
|
|
|
* simply a non-standard ArrayBuffer.
|
|
|
|
|
*
|
|
|
|
|
* ArrayBuffer is a fixed memory allocation. Deno.Buffer is implemented on top
|
|
|
|
|
* of ArrayBuffer.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer).
|
|
|
|
|
*
|
|
|
|
|
* @deprecated Use Buffer from https://deno.land/std/io/buffer.ts instead. Deno.Buffer will be removed in Deno 2.0.
|
|
|
|
|
* @category I/O
|
|
|
|
|
*/
|
2020-04-28 07:23:30 -04:00
|
|
|
|
export class Buffer implements Reader, ReaderSync, Writer, WriterSync {
|
2019-08-30 11:11:33 -04:00
|
|
|
|
constructor(ab?: ArrayBuffer);
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Returns a slice holding the unread portion of the buffer.
|
|
|
|
|
*
|
2019-08-30 11:11:33 -04:00
|
|
|
|
* The slice is valid for use only until the next buffer modification (that
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* is, only until the next call to a method like `read()`, `write()`,
|
2020-07-13 00:58:59 -04:00
|
|
|
|
* `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* least until the next buffer modification, so immediate changes to the
|
2020-07-13 00:58:59 -04:00
|
|
|
|
* slice will affect the result of future reads.
|
|
|
|
|
* @param options Defaults to `{ copy: true }`
|
|
|
|
|
*/
|
|
|
|
|
bytes(options?: { copy?: boolean }): Uint8Array;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Returns whether the unread portion of the buffer is empty. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
empty(): boolean;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** A read only number of bytes of the unread portion of the buffer. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
readonly length: number;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** The read only capacity of the buffer's underlying byte slice, that is,
|
|
|
|
|
* the total space allocated for the buffer's data. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
readonly capacity: number;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Discards all but the first `n` unread bytes from the buffer but
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* continues to use the same allocated storage. It throws if `n` is
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* negative or greater than the length of the buffer. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
truncate(n: number): void;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Resets the buffer to be empty, but it retains the underlying storage for
|
|
|
|
|
* use by future writes. `.reset()` is the same as `.truncate(0)`. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
reset(): void;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Reads the next `p.length` bytes from the buffer or until the buffer is
|
|
|
|
|
* drained. Returns the number of bytes read. If the buffer has no data to
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* return, the return is EOF (`null`). */
|
|
|
|
|
readSync(p: Uint8Array): number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Reads the next `p.length` bytes from the buffer or until the buffer is
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* drained. Resolves to the number of bytes read. If the buffer has no
|
2020-04-29 16:38:10 -04:00
|
|
|
|
* data to return, resolves to EOF (`null`).
|
|
|
|
|
*
|
2020-08-31 22:18:06 -04:00
|
|
|
|
* NOTE: This methods reads bytes synchronously; it's provided for
|
2020-04-29 16:38:10 -04:00
|
|
|
|
* compatibility with `Reader` interfaces.
|
|
|
|
|
*/
|
2020-04-28 12:40:43 -04:00
|
|
|
|
read(p: Uint8Array): Promise<number | null>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
writeSync(p: Uint8Array): number;
|
2020-08-31 22:18:06 -04:00
|
|
|
|
/** NOTE: This methods writes bytes synchronously; it's provided for
|
2020-04-29 16:38:10 -04:00
|
|
|
|
* compatibility with `Writer` interface. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
write(p: Uint8Array): Promise<number>;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Grows the buffer's capacity, if necessary, to guarantee space for
|
|
|
|
|
* another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
|
|
|
|
|
* the buffer without another allocation. If `n` is negative, `.grow()` will
|
|
|
|
|
* throw. If the buffer can't grow it will throw an error.
|
|
|
|
|
*
|
|
|
|
|
* Based on Go Lang's
|
|
|
|
|
* [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
grow(n: number): void;
|
2020-04-28 12:40:43 -04:00
|
|
|
|
/** Reads data from `r` until EOF (`null`) and appends it to the buffer,
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* growing the buffer as needed. It resolves to the number of bytes read.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* If the buffer becomes too large, `.readFrom()` will reject with an error.
|
|
|
|
|
*
|
|
|
|
|
* Based on Go Lang's
|
|
|
|
|
* [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
readFrom(r: Reader): Promise<number>;
|
2020-04-28 12:40:43 -04:00
|
|
|
|
/** Reads data from `r` until EOF (`null`) and appends it to the buffer,
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* growing the buffer as needed. It returns the number of bytes read. If the
|
|
|
|
|
* buffer becomes too large, `.readFromSync()` will throw an error.
|
|
|
|
|
*
|
|
|
|
|
* Based on Go Lang's
|
|
|
|
|
* [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
|
2020-04-28 07:23:30 -04:00
|
|
|
|
readFromSync(r: ReaderSync): number;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2021-04-05 18:05:36 -04:00
|
|
|
|
/**
|
|
|
|
|
* Read Reader `r` until EOF (`null`) and resolve to the content as
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* Uint8Array`.
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // Example from stdin
|
|
|
|
|
* const stdinContent = await Deno.readAll(Deno.stdin);
|
|
|
|
|
*
|
|
|
|
|
* // Example from file
|
|
|
|
|
* const file = await Deno.open("my_file.txt", {read: true});
|
|
|
|
|
* const myFileContent = await Deno.readAll(file);
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
*
|
|
|
|
|
* // Example from buffer
|
|
|
|
|
* const myData = new Uint8Array(100);
|
|
|
|
|
* // ... fill myData array with data
|
|
|
|
|
* const reader = new Deno.Buffer(myData.buffer as ArrayBuffer);
|
|
|
|
|
* const bufferContent = await Deno.readAll(reader);
|
|
|
|
|
* ```
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `readAll` from https://deno.land/std/streams/conversion.ts
|
|
|
|
|
* instead. `Deno.readAll` will be removed in Deno 2.0.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function readAll(r: Reader): Promise<Uint8Array>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2021-04-05 18:05:36 -04:00
|
|
|
|
/**
|
|
|
|
|
* Synchronously reads Reader `r` until EOF (`null`) and returns the content
|
2020-04-28 12:40:43 -04:00
|
|
|
|
* as `Uint8Array`.
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // Example from stdin
|
|
|
|
|
* const stdinContent = Deno.readAllSync(Deno.stdin);
|
|
|
|
|
*
|
|
|
|
|
* // Example from file
|
|
|
|
|
* const file = Deno.openSync("my_file.txt", {read: true});
|
|
|
|
|
* const myFileContent = Deno.readAllSync(file);
|
|
|
|
|
* Deno.close(file.rid);
|
|
|
|
|
*
|
|
|
|
|
* // Example from buffer
|
|
|
|
|
* const myData = new Uint8Array(100);
|
|
|
|
|
* // ... fill myData array with data
|
|
|
|
|
* const reader = new Deno.Buffer(myData.buffer as ArrayBuffer);
|
|
|
|
|
* const bufferContent = Deno.readAllSync(reader);
|
|
|
|
|
* ```
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `readAllSync` from
|
|
|
|
|
* https://deno.land/std/streams/conversion.ts instead. `Deno.readAllSync`
|
|
|
|
|
* will be removed in Deno 2.0.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*/
|
2020-04-28 07:23:30 -04:00
|
|
|
|
export function readAllSync(r: ReaderSync): Uint8Array;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2021-04-05 18:05:36 -04:00
|
|
|
|
/**
|
|
|
|
|
* Write all the content of the array buffer (`arr`) to the writer (`w`).
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // Example writing to stdout
|
|
|
|
|
* const contentBytes = new TextEncoder().encode("Hello World");
|
|
|
|
|
* await Deno.writeAll(Deno.stdout, contentBytes);
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```
|
2020-05-16 15:23:48 -04:00
|
|
|
|
*
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```ts
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // Example writing to file
|
|
|
|
|
* const contentBytes = new TextEncoder().encode("Hello World");
|
|
|
|
|
* const file = await Deno.open('test.file', {write: true});
|
|
|
|
|
* await Deno.writeAll(file, contentBytes);
|
|
|
|
|
* Deno.close(file.rid);
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```
|
2020-05-16 15:23:48 -04:00
|
|
|
|
*
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```ts
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // Example writing to buffer
|
|
|
|
|
* const contentBytes = new TextEncoder().encode("Hello World");
|
|
|
|
|
* const writer = new Deno.Buffer();
|
|
|
|
|
* await Deno.writeAll(writer, contentBytes);
|
|
|
|
|
* console.log(writer.bytes().length); // 11
|
|
|
|
|
* ```
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `writeAll` from https://deno.land/std/streams/conversion.ts
|
|
|
|
|
* instead. `Deno.writeAll` will be removed in Deno 2.0.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function writeAll(w: Writer, arr: Uint8Array): Promise<void>;
|
|
|
|
|
|
2021-04-05 18:05:36 -04:00
|
|
|
|
/**
|
|
|
|
|
* Synchronously write all the content of the array buffer (`arr`) to the
|
2020-03-31 23:21:37 -04:00
|
|
|
|
* writer (`w`).
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // Example writing to stdout
|
|
|
|
|
* const contentBytes = new TextEncoder().encode("Hello World");
|
|
|
|
|
* Deno.writeAllSync(Deno.stdout, contentBytes);
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```
|
2020-05-16 15:23:48 -04:00
|
|
|
|
*
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```ts
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // Example writing to file
|
|
|
|
|
* const contentBytes = new TextEncoder().encode("Hello World");
|
|
|
|
|
* const file = Deno.openSync('test.file', {write: true});
|
|
|
|
|
* Deno.writeAllSync(file, contentBytes);
|
|
|
|
|
* Deno.close(file.rid);
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```
|
2020-05-16 15:23:48 -04:00
|
|
|
|
*
|
2021-05-05 01:55:21 -04:00
|
|
|
|
* ```ts
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // Example writing to buffer
|
|
|
|
|
* const contentBytes = new TextEncoder().encode("Hello World");
|
|
|
|
|
* const writer = new Deno.Buffer();
|
|
|
|
|
* Deno.writeAllSync(writer, contentBytes);
|
|
|
|
|
* console.log(writer.bytes().length); // 11
|
|
|
|
|
* ```
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Use `writeAllSync` from
|
|
|
|
|
* https://deno.land/std/streams/conversion.ts instead. `Deno.writeAllSync`
|
|
|
|
|
* will be removed in Deno 2.0.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category I/O
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*/
|
2020-04-28 07:23:30 -04:00
|
|
|
|
export function writeAllSync(w: WriterSync, arr: Uint8Array): void;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2020-03-02 15:24:42 -05:00
|
|
|
|
export interface MkdirOptions {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Defaults to `false`. If set to `true`, means that any intermediate
|
|
|
|
|
* directories will also be created (as with the shell command `mkdir -p`).
|
|
|
|
|
* Intermediate directories are created with the same permissions.
|
|
|
|
|
* When recursive is set to `true`, succeeds silently (without changing any
|
2020-04-02 14:54:33 -04:00
|
|
|
|
* permissions) if a directory already exists at the path, or if the path
|
|
|
|
|
* is a symlink to an existing directory. */
|
2020-01-07 14:14:33 -05:00
|
|
|
|
recursive?: boolean;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Permissions to use when creating the directory (defaults to `0o777`,
|
|
|
|
|
* before the process's umask).
|
2020-03-11 16:14:23 -04:00
|
|
|
|
* Ignored on Windows. */
|
2020-01-07 14:14:33 -05:00
|
|
|
|
mode?: number;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Synchronously creates a new directory with the specified path.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.mkdirSync("new_dir");
|
|
|
|
|
* Deno.mkdirSync("nested/directories", { recursive: true });
|
|
|
|
|
* Deno.mkdirSync("restricted_access_dir", { mode: 0o700 });
|
|
|
|
|
* ```
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*
|
2020-04-02 14:54:33 -04:00
|
|
|
|
* Defaults to throwing error if the directory already exists.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function mkdirSync(path: string | URL, options?: MkdirOptions): void;
|
2020-01-07 14:14:33 -05:00
|
|
|
|
|
2019-08-30 11:11:33 -04:00
|
|
|
|
/** Creates a new directory with the specified path.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.mkdir("new_dir");
|
|
|
|
|
* await Deno.mkdir("nested/directories", { recursive: true });
|
|
|
|
|
* await Deno.mkdir("restricted_access_dir", { mode: 0o700 });
|
|
|
|
|
* ```
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*
|
2020-04-02 14:54:33 -04:00
|
|
|
|
* Defaults to throwing error if the directory already exists.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function mkdir(
|
|
|
|
|
path: string | URL,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: MkdirOptions,
|
2020-06-11 12:36:20 -04:00
|
|
|
|
): Promise<void>;
|
2020-01-07 14:14:33 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2020-02-18 14:45:59 -05:00
|
|
|
|
export interface MakeTempOptions {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Directory where the temporary directory should be created (defaults to
|
2020-05-29 11:27:43 -04:00
|
|
|
|
* the env variable TMPDIR, or the system's default, usually /tmp).
|
|
|
|
|
*
|
|
|
|
|
* Note that if the passed `dir` is relative, the path returned by
|
|
|
|
|
* makeTempFile() and makeTempDir() will also be relative. Be mindful of
|
|
|
|
|
* this when changing working directory. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
dir?: string;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** String that should precede the random portion of the temporary
|
|
|
|
|
* directory's name. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
prefix?: string;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** String that should follow the random portion of the temporary
|
|
|
|
|
* directory's name. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
suffix?: string;
|
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Synchronously creates a new temporary directory in the default directory
|
2020-08-21 09:56:12 -04:00
|
|
|
|
* for temporary files, unless `dir` is specified. Other optional options
|
|
|
|
|
* include prefixing and suffixing the directory name with `prefix` and
|
|
|
|
|
* `suffix` respectively.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* The full path to the newly created directory is returned.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Multiple programs calling this function simultaneously will create different
|
|
|
|
|
* directories. It is the caller's responsibility to remove the directory when
|
|
|
|
|
* no longer needed.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const tempDirName0 = Deno.makeTempDirSync(); // e.g. /tmp/2894ea76
|
|
|
|
|
* const tempDirName1 = Deno.makeTempDirSync({ prefix: 'my_temp' }); // e.g. /tmp/my_temp339c944d
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-01-17 19:01:24 -05:00
|
|
|
|
// TODO(ry) Doesn't check permissions.
|
2020-02-18 14:45:59 -05:00
|
|
|
|
export function makeTempDirSync(options?: MakeTempOptions): string;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Creates a new temporary directory in the default directory for temporary
|
2020-08-21 09:56:12 -04:00
|
|
|
|
* files, unless `dir` is specified. Other optional options include
|
|
|
|
|
* prefixing and suffixing the directory name with `prefix` and `suffix`
|
|
|
|
|
* respectively.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* This call resolves to the full path to the newly created directory.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Multiple programs calling this function simultaneously will create different
|
|
|
|
|
* directories. It is the caller's responsibility to remove the directory when
|
|
|
|
|
* no longer needed.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const tempDirName0 = await Deno.makeTempDir(); // e.g. /tmp/2894ea76
|
|
|
|
|
* const tempDirName1 = await Deno.makeTempDir({ prefix: 'my_temp' }); // e.g. /tmp/my_temp339c944d
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-01-17 19:01:24 -05:00
|
|
|
|
// TODO(ry) Doesn't check permissions.
|
2020-02-18 14:45:59 -05:00
|
|
|
|
export function makeTempDir(options?: MakeTempOptions): Promise<string>;
|
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Synchronously creates a new temporary file in the default directory for
|
2020-12-12 07:16:52 -05:00
|
|
|
|
* temporary files, unless `dir` is specified.
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* Other optional options include prefixing and suffixing the directory name
|
|
|
|
|
* with `prefix` and `suffix` respectively.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* The full path to the newly created file is returned.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Multiple programs calling this function simultaneously will create different
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* files. It is the caller's responsibility to remove the file when no longer
|
|
|
|
|
* needed.
|
2020-02-18 14:45:59 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const tempFileName0 = Deno.makeTempFileSync(); // e.g. /tmp/419e0bf2
|
|
|
|
|
* const tempFileName1 = Deno.makeTempFileSync({ prefix: 'my_temp' }); // e.g. /tmp/my_temp754d3098
|
|
|
|
|
* ```
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-02-18 14:45:59 -05:00
|
|
|
|
export function makeTempFileSync(options?: MakeTempOptions): string;
|
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Creates a new temporary file in the default directory for temporary
|
2020-12-12 07:16:52 -05:00
|
|
|
|
* files, unless `dir` is specified. Other
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* optional options include prefixing and suffixing the directory name with
|
|
|
|
|
* `prefix` and `suffix` respectively.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* This call resolves to the full path to the newly created file.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Multiple programs calling this function simultaneously will create different
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* files. It is the caller's responsibility to remove the file when no longer
|
|
|
|
|
* needed.
|
2020-02-18 14:45:59 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const tmpFileName0 = await Deno.makeTempFile(); // e.g. /tmp/419e0bf2
|
|
|
|
|
* const tmpFileName1 = await Deno.makeTempFile({ prefix: 'my_temp' }); // e.g. /tmp/my_temp754d3098
|
|
|
|
|
* ```
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-02-18 14:45:59 -05:00
|
|
|
|
export function makeTempFile(options?: MakeTempOptions): Promise<string>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Synchronously changes the permission of a specific file/directory of
|
|
|
|
|
* specified path. Ignores the process's umask.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.chmodSync("/path/to/file", 0o666);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-09-04 06:43:51 -04:00
|
|
|
|
* For a full description, see [chmod](#Deno.chmod)
|
2020-03-18 21:25:01 -04:00
|
|
|
|
*
|
2020-03-20 16:03:04 -04:00
|
|
|
|
* NOTE: This API currently throws on Windows
|
2020-03-18 21:25:01 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function chmodSync(path: string | URL, mode: number): void;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2019-08-30 11:11:33 -04:00
|
|
|
|
/** Changes the permission of a specific file/directory of specified path.
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Ignores the process's umask.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.chmod("/path/to/file", 0o666);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-18 21:25:01 -04:00
|
|
|
|
* The mode is a sequence of 3 octal numbers. The first/left-most number
|
|
|
|
|
* specifies the permissions for the owner. The second number specifies the
|
|
|
|
|
* permissions for the group. The last/right-most number specifies the
|
|
|
|
|
* permissions for others. For example, with a mode of 0o764, the owner (7) can
|
|
|
|
|
* read/write/execute, the group (6) can read/write and everyone else (4) can
|
|
|
|
|
* read only.
|
|
|
|
|
*
|
|
|
|
|
* | Number | Description |
|
|
|
|
|
* | ------ | ----------- |
|
|
|
|
|
* | 7 | read, write, and execute |
|
|
|
|
|
* | 6 | read and write |
|
|
|
|
|
* | 5 | read and execute |
|
|
|
|
|
* | 4 | read only |
|
|
|
|
|
* | 3 | write and execute |
|
|
|
|
|
* | 2 | write only |
|
|
|
|
|
* | 1 | execute only |
|
|
|
|
|
* | 0 | no permission |
|
|
|
|
|
*
|
2020-03-20 16:03:04 -04:00
|
|
|
|
* NOTE: This API currently throws on Windows
|
2020-03-18 21:25:01 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function chmod(path: string | URL, mode: number): Promise<void>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-23 00:03:45 -04:00
|
|
|
|
/** Synchronously change owner of a regular file or directory. This functionality
|
|
|
|
|
* is not available on Windows.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.chownSync("myFile.txt", 1000, 1002);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Requires `allow-write` permission.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-23 00:03:45 -04:00
|
|
|
|
* Throws Error (not implemented) if executed on Windows
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*
|
2019-08-30 11:11:33 -04:00
|
|
|
|
* @param path path to the file
|
2020-07-06 07:15:13 -04:00
|
|
|
|
* @param uid user id (UID) of the new owner, or `null` for no change
|
|
|
|
|
* @param gid group id (GID) of the new owner, or `null` for no change
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-07-06 07:15:13 -04:00
|
|
|
|
export function chownSync(
|
|
|
|
|
path: string | URL,
|
|
|
|
|
uid: number | null,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
gid: number | null,
|
2020-07-06 07:15:13 -04:00
|
|
|
|
): void;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-23 00:03:45 -04:00
|
|
|
|
/** Change owner of a regular file or directory. This functionality
|
|
|
|
|
* is not available on Windows.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.chown("myFile.txt", 1000, 1002);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Requires `allow-write` permission.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-23 00:03:45 -04:00
|
|
|
|
* Throws Error (not implemented) if executed on Windows
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*
|
2019-08-30 11:11:33 -04:00
|
|
|
|
* @param path path to the file
|
2020-07-06 07:15:13 -04:00
|
|
|
|
* @param uid user id (UID) of the new owner, or `null` for no change
|
|
|
|
|
* @param gid group id (GID) of the new owner, or `null` for no change
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function chown(
|
|
|
|
|
path: string | URL,
|
2020-07-06 07:15:13 -04:00
|
|
|
|
uid: number | null,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
gid: number | null,
|
2020-06-11 12:36:20 -04:00
|
|
|
|
): Promise<void>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2020-03-02 15:24:42 -05:00
|
|
|
|
export interface RemoveOptions {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Defaults to `false`. If set to `true`, path will be removed even if
|
|
|
|
|
* it's a non-empty directory. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
recursive?: boolean;
|
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Synchronously removes the named file or directory.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.removeSync("/path/to/empty_dir/or/file");
|
|
|
|
|
* Deno.removeSync("/path/to/populated_dir/or/file", { recursive: true });
|
|
|
|
|
* ```
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
|
|
|
|
* Throws error if permission denied, path not found, or path is a non-empty
|
|
|
|
|
* directory and the `recursive` option isn't set to `true`.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function removeSync(path: string | URL, options?: RemoveOptions): void;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Removes the named file or directory.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.remove("/path/to/empty_dir/or/file");
|
|
|
|
|
* await Deno.remove("/path/to/populated_dir/or/file", { recursive: true });
|
|
|
|
|
* ```
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-03-31 23:21:37 -04:00
|
|
|
|
* Throws error if permission denied, path not found, or path is a non-empty
|
|
|
|
|
* directory and the `recursive` option isn't set to `true`.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function remove(
|
|
|
|
|
path: string | URL,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: RemoveOptions,
|
2020-06-11 12:36:20 -04:00
|
|
|
|
): Promise<void>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Synchronously renames (moves) `oldpath` to `newpath`. Paths may be files or
|
|
|
|
|
* directories. If `newpath` already exists and is not a directory,
|
|
|
|
|
* `renameSync()` replaces it. OS-specific restrictions may apply when
|
|
|
|
|
* `oldpath` and `newpath` are in different directories.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.renameSync("old/path", "new/path");
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-04-03 11:00:16 -04:00
|
|
|
|
* On Unix, this operation does not follow symlinks at either path.
|
|
|
|
|
*
|
|
|
|
|
* It varies between platforms when the operation throws errors, and if so what
|
|
|
|
|
* they are. It's always an error to rename anything to a non-empty directory.
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` and `allow-write` permissions.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-06-03 10:14:37 -04:00
|
|
|
|
export function renameSync(
|
|
|
|
|
oldpath: string | URL,
|
|
|
|
|
newpath: string | URL,
|
|
|
|
|
): void;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Renames (moves) `oldpath` to `newpath`. Paths may be files or directories.
|
|
|
|
|
* If `newpath` already exists and is not a directory, `rename()` replaces it.
|
|
|
|
|
* OS-specific restrictions may apply when `oldpath` and `newpath` are in
|
|
|
|
|
* different directories.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.rename("old/path", "new/path");
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-04-03 11:00:16 -04:00
|
|
|
|
* On Unix, this operation does not follow symlinks at either path.
|
|
|
|
|
*
|
|
|
|
|
* It varies between platforms when the operation throws errors, and if so what
|
|
|
|
|
* they are. It's always an error to rename anything to a non-empty directory.
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` and `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-06-03 10:14:37 -04:00
|
|
|
|
export function rename(
|
|
|
|
|
oldpath: string | URL,
|
|
|
|
|
newpath: string | URL,
|
|
|
|
|
): Promise<void>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-10-14 10:28:21 -04:00
|
|
|
|
/** Synchronously reads and returns the entire contents of a file as utf8
|
2020-10-19 09:06:04 -04:00
|
|
|
|
* encoded string. Reading a directory throws an error.
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const data = Deno.readTextFileSync("hello.txt");
|
|
|
|
|
* console.log(data);
|
|
|
|
|
* ```
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function readTextFileSync(path: string | URL): string;
|
2020-04-28 01:35:20 -04:00
|
|
|
|
|
2020-10-14 10:28:21 -04:00
|
|
|
|
/** Asynchronously reads and returns the entire contents of a file as utf8
|
2020-10-19 09:06:04 -04:00
|
|
|
|
* encoded string. Reading a directory throws an error.
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const data = await Deno.readTextFile("hello.txt");
|
|
|
|
|
* console.log(data);
|
|
|
|
|
* ```
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-06-22 11:45:26 -04:00
|
|
|
|
export function readTextFile(
|
|
|
|
|
path: string | URL,
|
|
|
|
|
options?: ReadFileOptions,
|
|
|
|
|
): Promise<string>;
|
2020-04-28 01:35:20 -04:00
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Synchronously reads and returns the entire contents of a file as an array
|
|
|
|
|
* of bytes. `TextDecoder` can be used to transform the bytes to string if
|
|
|
|
|
* required. Reading a directory returns an empty data array.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = Deno.readFileSync("hello.txt");
|
|
|
|
|
* console.log(decoder.decode(data));
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function readFileSync(path: string | URL): Uint8Array;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Reads and resolves to the entire contents of a file as an array of bytes.
|
|
|
|
|
* `TextDecoder` can be used to transform the bytes to string if required.
|
|
|
|
|
* Reading a directory returns an empty data array.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const decoder = new TextDecoder("utf-8");
|
|
|
|
|
* const data = await Deno.readFile("hello.txt");
|
|
|
|
|
* console.log(decoder.decode(data));
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-06-22 11:45:26 -04:00
|
|
|
|
export function readFile(
|
|
|
|
|
path: string | URL,
|
|
|
|
|
options?: ReadFileOptions,
|
|
|
|
|
): Promise<Uint8Array>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-14 22:57:42 -04:00
|
|
|
|
/** A FileInfo describes a file and is returned by `stat`, `lstat`,
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* `statSync`, `lstatSync`.
|
|
|
|
|
*
|
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export interface FileInfo {
|
2020-04-16 01:40:30 -04:00
|
|
|
|
/** True if this is info for a regular file. Mutually exclusive to
|
|
|
|
|
* `FileInfo.isDirectory` and `FileInfo.isSymlink`. */
|
|
|
|
|
isFile: boolean;
|
|
|
|
|
/** True if this is info for a regular directory. Mutually exclusive to
|
|
|
|
|
* `FileInfo.isFile` and `FileInfo.isSymlink`. */
|
|
|
|
|
isDirectory: boolean;
|
|
|
|
|
/** True if this is info for a symlink. Mutually exclusive to
|
|
|
|
|
* `FileInfo.isFile` and `FileInfo.isDirectory`. */
|
|
|
|
|
isSymlink: boolean;
|
2020-03-14 22:57:42 -04:00
|
|
|
|
/** The size of the file, in bytes. */
|
|
|
|
|
size: number;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
/** The last modification time of the file. This corresponds to the `mtime`
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* field from `stat` on Linux/Mac OS and `ftLastWriteTime` on Windows. This
|
|
|
|
|
* may not be available on all platforms. */
|
2020-04-27 14:09:56 -04:00
|
|
|
|
mtime: Date | null;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** The last access time of the file. This corresponds to the `atime`
|
|
|
|
|
* field from `stat` on Unix and `ftLastAccessTime` on Windows. This may not
|
|
|
|
|
* be available on all platforms. */
|
2020-04-27 14:09:56 -04:00
|
|
|
|
atime: Date | null;
|
2020-04-18 00:05:33 -04:00
|
|
|
|
/** The creation time of the file. This corresponds to the `birthtime`
|
2020-04-27 14:09:56 -04:00
|
|
|
|
* field from `stat` on Mac/BSD and `ftCreationTime` on Windows. This may
|
|
|
|
|
* not be available on all platforms. */
|
|
|
|
|
birthtime: Date | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** ID of the device containing the file.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
dev: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Inode number.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
ino: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** **UNSTABLE**: Match behavior with Go on Windows for `mode`.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-07 22:29:12 -05:00
|
|
|
|
* The underlying raw `st_mode` bits that contain the standard Unix
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* permissions for this file/directory. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
mode: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Number of hard links pointing to this file.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
nlink: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** User ID of the owner of this file.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
uid: number | null;
|
2020-04-18 11:25:35 -04:00
|
|
|
|
/** Group ID of the owner of this file.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
gid: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Device ID of this file.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
rdev: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Blocksize for filesystem I/O.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
blksize: number | null;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Number of blocks allocated to the file, in 512-byte units.
|
|
|
|
|
*
|
|
|
|
|
* _Linux/Mac OS only._ */
|
2020-01-16 09:46:32 -05:00
|
|
|
|
blocks: number | null;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Returns absolute normalized path, with symbolic links resolved.
|
2019-11-26 03:40:57 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // e.g. given /home/alice/file.txt and current directory /home/alice
|
|
|
|
|
* Deno.symlinkSync("file.txt", "symlink_file.txt");
|
|
|
|
|
* const realPath = Deno.realPathSync("./file.txt");
|
|
|
|
|
* const realSymLinkPath = Deno.realPathSync("./symlink_file.txt");
|
|
|
|
|
* console.log(realPath); // outputs "/home/alice/file.txt"
|
|
|
|
|
* console.log(realSymLinkPath); // outputs "/home/alice/file.txt"
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-05-29 11:27:43 -04:00
|
|
|
|
* Requires `allow-read` permission for the target path.
|
|
|
|
|
* Also requires `allow-read` permission for the CWD if the target path is
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* relative.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-05-17 00:31:21 -04:00
|
|
|
|
export function realPathSync(path: string | URL): string;
|
2019-11-26 03:40:57 -05:00
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Resolves to the absolute normalized path, with symbolic links resolved.
|
2019-11-26 03:40:57 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // e.g. given /home/alice/file.txt and current directory /home/alice
|
|
|
|
|
* await Deno.symlink("file.txt", "symlink_file.txt");
|
|
|
|
|
* const realPath = await Deno.realPath("./file.txt");
|
|
|
|
|
* const realSymLinkPath = await Deno.realPath("./symlink_file.txt");
|
|
|
|
|
* console.log(realPath); // outputs "/home/alice/file.txt"
|
|
|
|
|
* console.log(realSymLinkPath); // outputs "/home/alice/file.txt"
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-05-29 11:27:43 -04:00
|
|
|
|
* Requires `allow-read` permission for the target path.
|
|
|
|
|
* Also requires `allow-read` permission for the CWD if the target path is
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* relative.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-05-17 00:31:21 -04:00
|
|
|
|
export function realPath(path: string | URL): Promise<string>;
|
2019-11-26 03:40:57 -05:00
|
|
|
|
|
2020-04-29 16:00:31 -04:00
|
|
|
|
export interface DirEntry {
|
2020-04-16 01:40:30 -04:00
|
|
|
|
name: string;
|
2020-04-29 16:00:31 -04:00
|
|
|
|
isFile: boolean;
|
|
|
|
|
isDirectory: boolean;
|
|
|
|
|
isSymlink: boolean;
|
2020-04-16 01:40:30 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** Synchronously reads the directory given by `path` and returns an iterable
|
|
|
|
|
* of `Deno.DirEntry`.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* for (const dirEntry of Deno.readDirSync("/")) {
|
|
|
|
|
* console.log(dirEntry.name);
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* Throws error if `path` is not a directory.
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function readDirSync(path: string | URL): Iterable<DirEntry>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-16 01:40:30 -04:00
|
|
|
|
/** Reads the directory given by `path` and returns an async iterable of
|
|
|
|
|
* `Deno.DirEntry`.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* for await (const dirEntry of Deno.readDir("/")) {
|
|
|
|
|
* console.log(dirEntry.name);
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* Throws error if `path` is not a directory.
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function readDir(path: string | URL): AsyncIterable<DirEntry>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Synchronously copies the contents and permissions of one file to another
|
|
|
|
|
* specified path, by default creating a new file if needed, else overwriting.
|
|
|
|
|
* Fails if target path is a directory or is unwritable.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.copyFileSync("from.txt", "to.txt");
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Requires `allow-read` permission on fromPath.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission on toPath.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function copyFileSync(
|
|
|
|
|
fromPath: string | URL,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
toPath: string | URL,
|
2020-06-11 12:36:20 -04:00
|
|
|
|
): void;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Copies the contents and permissions of one file to another specified path,
|
|
|
|
|
* by default creating a new file if needed, else overwriting. Fails if target
|
|
|
|
|
* path is a directory or is unwritable.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.copyFile("from.txt", "to.txt");
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* Requires `allow-read` permission on fromPath.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission on toPath.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function copyFile(
|
|
|
|
|
fromPath: string | URL,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
toPath: string | URL,
|
2020-06-11 12:36:20 -04:00
|
|
|
|
): Promise<void>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Returns the full path destination of the named symbolic link.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.symlinkSync("./test.txt", "./test_link.txt");
|
|
|
|
|
* const target = Deno.readLinkSync("./test_link.txt"); // full path of ./test.txt
|
|
|
|
|
* ```
|
2020-03-29 21:39:10 -04:00
|
|
|
|
*
|
|
|
|
|
* Throws TypeError if called with a hard link
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-11-23 16:11:56 -05:00
|
|
|
|
export function readLinkSync(path: string | URL): string;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-29 21:39:10 -04:00
|
|
|
|
/** Resolves to the full path destination of the named symbolic link.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.symlink("./test.txt", "./test_link.txt");
|
|
|
|
|
* const target = await Deno.readLink("./test_link.txt"); // full path of ./test.txt
|
|
|
|
|
* ```
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* Throws TypeError if called with a hard link
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-11-23 16:11:56 -05:00
|
|
|
|
export function readLink(path: string | URL): Promise<string>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2020-03-06 11:29:23 -05:00
|
|
|
|
/** Resolves to a `Deno.FileInfo` for the specified `path`. If `path` is a
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* symlink, information for the symlink will be returned instead of what it
|
|
|
|
|
* points to.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2020-06-01 09:53:43 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const fileInfo = await Deno.lstat("hello.txt");
|
|
|
|
|
* assert(fileInfo.isFile);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function lstat(path: string | URL): Promise<FileInfo>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-06 11:29:23 -05:00
|
|
|
|
/** Synchronously returns a `Deno.FileInfo` for the specified `path`. If
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* `path` is a symlink, information for the symlink will be returned instead of
|
|
|
|
|
* what it points to..
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2021-05-05 01:50:38 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const fileInfo = Deno.lstatSync("hello.txt");
|
|
|
|
|
* assert(fileInfo.isFile);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function lstatSync(path: string | URL): FileInfo;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-06 11:29:23 -05:00
|
|
|
|
/** Resolves to a `Deno.FileInfo` for the specified `path`. Will always
|
|
|
|
|
* follow symlinks.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2020-06-01 09:53:43 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const fileInfo = await Deno.stat("hello.txt");
|
|
|
|
|
* assert(fileInfo.isFile);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function stat(path: string | URL): Promise<FileInfo>;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2020-03-06 11:29:23 -05:00
|
|
|
|
/** Synchronously returns a `Deno.FileInfo` for the specified `path`. Will
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* always follow symlinks.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2020-06-01 09:53:43 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* const fileInfo = Deno.statSync("hello.txt");
|
|
|
|
|
* assert(fileInfo.isFile);
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function statSync(path: string | URL): FileInfo;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** Options for writing to a file.
|
|
|
|
|
*
|
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export interface WriteFileOptions {
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Defaults to `false`. If set to `true`, will append to a file instead of
|
|
|
|
|
* overwriting previous contents. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
append?: boolean;
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Sets the option to allow creating a new file, if one doesn't already
|
|
|
|
|
* exist at the specified path (defaults to `true`). */
|
|
|
|
|
create?: boolean;
|
|
|
|
|
/** Permissions always applied to file. */
|
2020-03-07 22:29:12 -05:00
|
|
|
|
mode?: number;
|
2021-08-06 13:21:29 -04:00
|
|
|
|
/**
|
|
|
|
|
* An abort signal to allow cancellation of the file write operation.
|
|
|
|
|
* If the signal becomes aborted the writeFile operation will be stopped
|
|
|
|
|
* and the promise returned will be rejected with an AbortError.
|
|
|
|
|
*/
|
|
|
|
|
signal?: AbortSignal;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Synchronously write `data` to the given `path`, by default creating a new
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* file if needed, else overwriting.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const encoder = new TextEncoder();
|
|
|
|
|
* const data = encoder.encode("Hello world\n");
|
|
|
|
|
* Deno.writeFileSync("hello1.txt", data); // overwrite "hello1.txt" or create it
|
|
|
|
|
* Deno.writeFileSync("hello2.txt", data, {create: false}); // only works if "hello2.txt" exists
|
|
|
|
|
* Deno.writeFileSync("hello3.txt", data, {mode: 0o777}); // set permissions on new file
|
|
|
|
|
* Deno.writeFileSync("hello4.txt", data, {append: true}); // add data to the end of the file
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-31 23:21:37 -04:00
|
|
|
|
* Requires `allow-write` permission, and `allow-read` if `options.create` is
|
|
|
|
|
* `false`.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
|
|
|
|
export function writeFileSync(
|
2020-06-11 12:36:20 -04:00
|
|
|
|
path: string | URL,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
data: Uint8Array,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: WriteFileOptions,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
): void;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Write `data` to the given `path`, by default creating a new file if needed,
|
2020-03-02 10:19:42 -05:00
|
|
|
|
* else overwriting.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const encoder = new TextEncoder();
|
|
|
|
|
* const data = encoder.encode("Hello world\n");
|
|
|
|
|
* await Deno.writeFile("hello1.txt", data); // overwrite "hello1.txt" or create it
|
|
|
|
|
* await Deno.writeFile("hello2.txt", data, {create: false}); // only works if "hello2.txt" exists
|
|
|
|
|
* await Deno.writeFile("hello3.txt", data, {mode: 0o777}); // set permissions on new file
|
|
|
|
|
* await Deno.writeFile("hello4.txt", data, {append: true}); // add data to the end of the file
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-03-31 23:21:37 -04:00
|
|
|
|
* Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
|
|
|
|
export function writeFile(
|
2020-06-11 12:36:20 -04:00
|
|
|
|
path: string | URL,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
data: Uint8Array,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: WriteFileOptions,
|
2019-08-30 11:11:33 -04:00
|
|
|
|
): Promise<void>;
|
|
|
|
|
|
2020-04-28 01:35:20 -04:00
|
|
|
|
/** Synchronously write string `data` to the given `path`, by default creating a new file if needed,
|
|
|
|
|
* else overwriting.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2020-08-04 06:16:04 -04:00
|
|
|
|
* Deno.writeTextFileSync("hello1.txt", "Hello world\n"); // overwrite "hello1.txt" or create it
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*
|
|
|
|
|
* Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*/
|
2020-07-08 09:38:22 -04:00
|
|
|
|
export function writeTextFileSync(
|
|
|
|
|
path: string | URL,
|
|
|
|
|
data: string,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: WriteFileOptions,
|
2020-07-08 09:38:22 -04:00
|
|
|
|
): void;
|
2020-04-28 01:35:20 -04:00
|
|
|
|
|
|
|
|
|
/** Asynchronously write string `data` to the given `path`, by default creating a new file if needed,
|
|
|
|
|
* else overwriting.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.writeTextFile("hello1.txt", "Hello world\n"); // overwrite "hello1.txt" or create it
|
|
|
|
|
* ```
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*
|
|
|
|
|
* Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-04-28 01:35:20 -04:00
|
|
|
|
*/
|
2020-06-11 12:36:20 -04:00
|
|
|
|
export function writeTextFile(
|
|
|
|
|
path: string | URL,
|
2020-07-08 09:38:22 -04:00
|
|
|
|
data: string,
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: WriteFileOptions,
|
2020-06-11 12:36:20 -04:00
|
|
|
|
): Promise<void>;
|
2020-04-28 01:35:20 -04:00
|
|
|
|
|
2020-03-02 10:19:42 -05:00
|
|
|
|
/** Synchronously truncates or extends the specified file, to reach the
|
2020-03-31 23:21:37 -04:00
|
|
|
|
* specified `len`. If `len` is not specified then the entire file contents
|
|
|
|
|
* are truncated.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // truncate the entire file
|
|
|
|
|
* Deno.truncateSync("my_file.txt");
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // truncate part of the file
|
|
|
|
|
* const file = Deno.makeTempFileSync();
|
|
|
|
|
* Deno.writeFileSync(file, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* Deno.truncateSync(file, 7);
|
|
|
|
|
* const data = Deno.readFileSync(file);
|
|
|
|
|
* console.log(new TextDecoder().decode(data));
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function truncateSync(name: string, len?: number): void;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
|
2020-03-31 23:21:37 -04:00
|
|
|
|
/** Truncates or extends the specified file, to reach the specified `len`. If
|
|
|
|
|
* `len` is not specified then the entire file contents are truncated.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // truncate the entire file
|
|
|
|
|
* await Deno.truncate("my_file.txt");
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* // truncate part of the file
|
|
|
|
|
* const file = await Deno.makeTempFile();
|
|
|
|
|
* await Deno.writeFile(file, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* await Deno.truncate(file, 7);
|
|
|
|
|
* const data = await Deno.readFile(file);
|
|
|
|
|
* console.log(new TextDecoder().decode(data)); // "Hello W"
|
|
|
|
|
* ```
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-write` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function truncate(name: string, len?: number): Promise<void>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Observability */
|
2021-10-10 11:20:30 -04:00
|
|
|
|
export interface OpMetrics {
|
2019-08-30 11:11:33 -04:00
|
|
|
|
opsDispatched: number;
|
2020-03-02 13:13:36 -05:00
|
|
|
|
opsDispatchedSync: number;
|
|
|
|
|
opsDispatchedAsync: number;
|
|
|
|
|
opsDispatchedAsyncUnref: number;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
opsCompleted: number;
|
2020-03-02 13:13:36 -05:00
|
|
|
|
opsCompletedSync: number;
|
|
|
|
|
opsCompletedAsync: number;
|
|
|
|
|
opsCompletedAsyncUnref: number;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
bytesSentControl: number;
|
|
|
|
|
bytesSentData: number;
|
|
|
|
|
bytesReceived: number;
|
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Observability */
|
2021-10-10 11:20:30 -04:00
|
|
|
|
export interface Metrics extends OpMetrics {
|
|
|
|
|
ops: Record<string, OpMetrics>;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-17 13:24:39 -04:00
|
|
|
|
/** Receive metrics from the privileged side of Deno. This is primarily used
|
2020-03-29 21:39:10 -04:00
|
|
|
|
* in the development of Deno. 'Ops', also called 'bindings', are the go-between
|
2020-05-17 13:24:39 -04:00
|
|
|
|
* between Deno JavaScript and Deno Rust.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
|
|
|
|
* > console.table(Deno.metrics())
|
2020-03-02 13:13:36 -05:00
|
|
|
|
* ┌─────────────────────────┬────────┐
|
|
|
|
|
* │ (index) │ Values │
|
|
|
|
|
* ├─────────────────────────┼────────┤
|
|
|
|
|
* │ opsDispatched │ 3 │
|
|
|
|
|
* │ opsDispatchedSync │ 2 │
|
|
|
|
|
* │ opsDispatchedAsync │ 1 │
|
|
|
|
|
* │ opsDispatchedAsyncUnref │ 0 │
|
|
|
|
|
* │ opsCompleted │ 3 │
|
|
|
|
|
* │ opsCompletedSync │ 2 │
|
|
|
|
|
* │ opsCompletedAsync │ 1 │
|
|
|
|
|
* │ opsCompletedAsyncUnref │ 0 │
|
|
|
|
|
* │ bytesSentControl │ 73 │
|
|
|
|
|
* │ bytesSentData │ 0 │
|
|
|
|
|
* │ bytesReceived │ 375 │
|
|
|
|
|
* └─────────────────────────┴────────┘
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Observability
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*/
|
|
|
|
|
export function metrics(): Metrics;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Observability */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
interface ResourceMap {
|
2020-11-03 10:19:29 -05:00
|
|
|
|
// deno-lint-ignore no-explicit-any
|
2020-04-25 16:02:15 -04:00
|
|
|
|
[rid: number]: any;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-25 16:02:15 -04:00
|
|
|
|
/** Returns a map of open resource ids (rid) along with their string
|
|
|
|
|
* representations. This is an internal API and as such resource
|
|
|
|
|
* representation has `any` type; that means it can change any time.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* console.log(Deno.resources());
|
|
|
|
|
* // { 0: "stdin", 1: "stdout", 2: "stderr" }
|
|
|
|
|
* Deno.openSync('../test.file');
|
|
|
|
|
* console.log(Deno.resources());
|
|
|
|
|
* // { 0: "stdin", 1: "stdout", 2: "stderr", 3: "fsFile" }
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Observability
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export function resources(): ResourceMap;
|
|
|
|
|
|
2021-11-23 05:30:24 -05:00
|
|
|
|
/**
|
|
|
|
|
* Additional information for FsEvent objects with the "other" kind.
|
|
|
|
|
*
|
|
|
|
|
* - "rescan": rescan notices indicate either a lapse in the events or a
|
|
|
|
|
* change in the filesystem such that events received so far can no longer
|
|
|
|
|
* be relied on to represent the state of the filesystem now. An
|
|
|
|
|
* application that simply reacts to file changes may not care about this.
|
|
|
|
|
* An application that keeps an in-memory representation of the filesystem
|
|
|
|
|
* will need to care, and will need to refresh that representation directly
|
|
|
|
|
* from the filesystem.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category File System
|
2021-11-23 05:30:24 -05:00
|
|
|
|
*/
|
|
|
|
|
export type FsEventFlag = "rescan";
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2020-02-21 13:21:51 -05:00
|
|
|
|
export interface FsEvent {
|
2021-11-23 05:30:24 -05:00
|
|
|
|
kind: "any" | "access" | "create" | "modify" | "remove" | "other";
|
2020-02-21 13:21:51 -05:00
|
|
|
|
paths: string[];
|
2021-11-23 05:30:24 -05:00
|
|
|
|
flag?: FsEventFlag;
|
2020-02-21 13:21:51 -05:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-01 02:35:06 -04:00
|
|
|
|
/**
|
|
|
|
|
* FsWatcher is returned by `Deno.watchFs` function when you start watching
|
|
|
|
|
* the file system. You can iterate over this interface to get the file
|
|
|
|
|
* system events, and also you can stop watching the file system by calling
|
|
|
|
|
* `.close()` method.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category File System
|
2021-06-01 02:35:06 -04:00
|
|
|
|
*/
|
|
|
|
|
export interface FsWatcher extends AsyncIterable<FsEvent> {
|
|
|
|
|
/** The resource id of the `FsWatcher`. */
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
/** Stops watching the file system and closes the watcher resource. */
|
|
|
|
|
close(): void;
|
2021-12-09 19:05:50 -05:00
|
|
|
|
/**
|
2021-06-01 02:35:06 -04:00
|
|
|
|
* Stops watching the file system and closes the watcher resource.
|
2021-12-09 19:05:50 -05:00
|
|
|
|
*
|
|
|
|
|
* @deprecated Will be removed at 2.0.
|
2021-06-01 02:35:06 -04:00
|
|
|
|
*/
|
|
|
|
|
return?(value?: any): Promise<IteratorResult<FsEvent>>;
|
|
|
|
|
[Symbol.asyncIterator](): AsyncIterableIterator<FsEvent>;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-24 17:40:29 -04:00
|
|
|
|
/** Watch for file system events against one or more `paths`, which can be files
|
2020-03-24 23:54:41 -04:00
|
|
|
|
* or directories. These paths must exist already. One user action (e.g.
|
|
|
|
|
* `touch test.file`) can generate multiple file system events. Likewise,
|
|
|
|
|
* one user action can result in multiple file paths in one event (e.g. `mv
|
|
|
|
|
* old_name.txt new_name.txt`). Recursive option is `true` by default and,
|
|
|
|
|
* for directories, will watch the specified directory and all sub directories.
|
|
|
|
|
* Note that the exact ordering of the events can vary between operating systems.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const watcher = Deno.watchFs("/");
|
|
|
|
|
* for await (const event of watcher) {
|
|
|
|
|
* console.log(">>>> event", event);
|
|
|
|
|
* // { kind: "create", paths: [ "/foo.txt" ] }
|
|
|
|
|
* }
|
2021-09-02 18:28:12 -04:00
|
|
|
|
* ```
|
2020-02-21 13:21:51 -05:00
|
|
|
|
*
|
2020-03-24 23:54:41 -04:00
|
|
|
|
* Requires `allow-read` permission.
|
2021-04-28 08:37:16 -04:00
|
|
|
|
*
|
2021-06-01 02:35:06 -04:00
|
|
|
|
* Call `watcher.close()` to stop watching.
|
2021-04-28 08:37:16 -04:00
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* const watcher = Deno.watchFs("/");
|
2021-05-10 22:18:29 -04:00
|
|
|
|
*
|
|
|
|
|
* setTimeout(() => {
|
2021-06-01 02:35:06 -04:00
|
|
|
|
* watcher.close();
|
2021-05-10 22:18:29 -04:00
|
|
|
|
* }, 5000);
|
|
|
|
|
*
|
2021-04-28 08:37:16 -04:00
|
|
|
|
* for await (const event of watcher) {
|
|
|
|
|
* console.log(">>>> event", event);
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
2020-03-24 23:54:41 -04:00
|
|
|
|
*/
|
2020-04-24 17:40:29 -04:00
|
|
|
|
export function watchFs(
|
2020-02-21 13:21:51 -05:00
|
|
|
|
paths: string | string[],
|
2020-07-14 15:24:17 -04:00
|
|
|
|
options?: { recursive: boolean },
|
2021-06-01 02:35:06 -04:00
|
|
|
|
): FsWatcher;
|
2020-02-21 13:21:51 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Runtime Environment */
|
2020-06-09 07:18:18 -04:00
|
|
|
|
export class Process<T extends RunOptions = RunOptions> {
|
2019-08-30 11:11:33 -04:00
|
|
|
|
readonly rid: number;
|
|
|
|
|
readonly pid: number;
|
2022-02-15 07:35:22 -05:00
|
|
|
|
readonly stdin: T["stdin"] extends "piped" ? Writer & Closer & {
|
2022-06-22 15:42:08 -04:00
|
|
|
|
writable: WritableStream<Uint8Array>;
|
|
|
|
|
}
|
2022-02-15 07:35:22 -05:00
|
|
|
|
: (Writer & Closer & { writable: WritableStream<Uint8Array> }) | null;
|
|
|
|
|
readonly stdout: T["stdout"] extends "piped" ? Reader & Closer & {
|
2022-06-22 15:42:08 -04:00
|
|
|
|
readable: ReadableStream<Uint8Array>;
|
|
|
|
|
}
|
2022-02-15 07:35:22 -05:00
|
|
|
|
: (Reader & Closer & { readable: ReadableStream<Uint8Array> }) | null;
|
|
|
|
|
readonly stderr: T["stderr"] extends "piped" ? Reader & Closer & {
|
2022-06-22 15:42:08 -04:00
|
|
|
|
readable: ReadableStream<Uint8Array>;
|
|
|
|
|
}
|
2022-02-15 07:35:22 -05:00
|
|
|
|
: (Reader & Closer & { readable: ReadableStream<Uint8Array> }) | null;
|
2021-02-04 07:09:00 -05:00
|
|
|
|
/** Wait for the process to exit and return its exit status.
|
|
|
|
|
*
|
|
|
|
|
* Calling this function multiple times will return the same status.
|
|
|
|
|
*
|
|
|
|
|
* Stdin handle to the process will be closed before waiting to avoid
|
|
|
|
|
* a deadlock.
|
|
|
|
|
*
|
|
|
|
|
* If `stdout` and/or `stderr` were set to `"piped"`, they must be closed
|
|
|
|
|
* manually before the process can exit.
|
2021-04-09 18:12:00 -04:00
|
|
|
|
*
|
2021-02-04 07:09:00 -05:00
|
|
|
|
* To run process to completion and collect output from both `stdout` and
|
|
|
|
|
* `stderr` use:
|
2021-04-09 18:12:00 -04:00
|
|
|
|
*
|
2021-02-04 07:09:00 -05:00
|
|
|
|
* ```ts
|
2021-05-10 22:11:17 -04:00
|
|
|
|
* const p = Deno.run({ cmd: [ "echo", "hello world" ], stderr: 'piped', stdout: 'piped' });
|
2021-02-04 07:09:00 -05:00
|
|
|
|
* const [status, stdout, stderr] = await Promise.all([
|
|
|
|
|
* p.status(),
|
|
|
|
|
* p.output(),
|
|
|
|
|
* p.stderrOutput()
|
|
|
|
|
* ]);
|
|
|
|
|
* p.close();
|
|
|
|
|
* ```
|
2021-09-02 18:28:12 -04:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
status(): Promise<ProcessStatus>;
|
2020-04-28 12:40:43 -04:00
|
|
|
|
/** Buffer the stdout until EOF and return it as `Uint8Array`.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
|
|
|
|
* You must set stdout to `"piped"` when creating the process.
|
|
|
|
|
*
|
|
|
|
|
* This calls `close()` on stdout after its done. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
output(): Promise<Uint8Array>;
|
2020-04-28 12:40:43 -04:00
|
|
|
|
/** Buffer the stderr until EOF and return it as `Uint8Array`.
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
|
|
|
|
* You must set stderr to `"piped"` when creating the process.
|
|
|
|
|
*
|
|
|
|
|
* This calls `close()` on stderr after its done. */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
stderrOutput(): Promise<Uint8Array>;
|
|
|
|
|
close(): void;
|
2020-04-27 23:36:43 -04:00
|
|
|
|
|
2021-10-10 09:48:26 -04:00
|
|
|
|
/** Send a signal to process.
|
2021-10-18 23:54:43 -04:00
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* const p = Deno.run({ cmd: [ "sleep", "20" ]});
|
|
|
|
|
* p.kill("SIGTERM");
|
|
|
|
|
* p.close();
|
|
|
|
|
* ```
|
2020-04-27 23:36:43 -04:00
|
|
|
|
*/
|
2021-10-10 09:48:26 -04:00
|
|
|
|
kill(signo: Signal): void;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Runtime Environment */
|
2021-10-10 09:48:26 -04:00
|
|
|
|
export type Signal =
|
|
|
|
|
| "SIGABRT"
|
|
|
|
|
| "SIGALRM"
|
2022-06-13 16:39:46 -04:00
|
|
|
|
| "SIGBREAK"
|
2021-10-10 09:48:26 -04:00
|
|
|
|
| "SIGBUS"
|
|
|
|
|
| "SIGCHLD"
|
|
|
|
|
| "SIGCONT"
|
|
|
|
|
| "SIGEMT"
|
|
|
|
|
| "SIGFPE"
|
|
|
|
|
| "SIGHUP"
|
|
|
|
|
| "SIGILL"
|
|
|
|
|
| "SIGINFO"
|
|
|
|
|
| "SIGINT"
|
|
|
|
|
| "SIGIO"
|
|
|
|
|
| "SIGKILL"
|
|
|
|
|
| "SIGPIPE"
|
|
|
|
|
| "SIGPROF"
|
|
|
|
|
| "SIGPWR"
|
|
|
|
|
| "SIGQUIT"
|
|
|
|
|
| "SIGSEGV"
|
|
|
|
|
| "SIGSTKFLT"
|
|
|
|
|
| "SIGSTOP"
|
|
|
|
|
| "SIGSYS"
|
|
|
|
|
| "SIGTERM"
|
|
|
|
|
| "SIGTRAP"
|
|
|
|
|
| "SIGTSTP"
|
|
|
|
|
| "SIGTTIN"
|
|
|
|
|
| "SIGTTOU"
|
|
|
|
|
| "SIGURG"
|
|
|
|
|
| "SIGUSR1"
|
|
|
|
|
| "SIGUSR2"
|
|
|
|
|
| "SIGVTALRM"
|
|
|
|
|
| "SIGWINCH"
|
|
|
|
|
| "SIGXCPU"
|
|
|
|
|
| "SIGXFSZ";
|
|
|
|
|
|
2022-01-31 00:16:39 -05:00
|
|
|
|
/** Registers the given function as a listener of the given signal event.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.addSignalListener("SIGTERM", () => {
|
|
|
|
|
* console.log("SIGTERM!")
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-06-13 16:39:46 -04:00
|
|
|
|
* NOTE: On Windows only SIGINT (ctrl+c) and SIGBREAK (ctrl+break) are supported.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
2022-01-31 00:16:39 -05:00
|
|
|
|
*/
|
|
|
|
|
export function addSignalListener(signal: Signal, handler: () => void): void;
|
|
|
|
|
|
|
|
|
|
/** Removes the given signal listener that has been registered with
|
|
|
|
|
* Deno.addSignalListener.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* const listener = () => {
|
|
|
|
|
* console.log("SIGTERM!")
|
|
|
|
|
* };
|
|
|
|
|
* Deno.addSignalListener("SIGTERM", listener);
|
|
|
|
|
* Deno.removeSignalListener("SIGTERM", listener);
|
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-06-13 16:39:46 -04:00
|
|
|
|
* NOTE: On Windows only SIGINT (ctrl+c) and SIGBREAK (ctrl+break) are supported.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
2022-01-31 00:16:39 -05:00
|
|
|
|
*/
|
|
|
|
|
export function removeSignalListener(
|
|
|
|
|
signal: Signal,
|
|
|
|
|
handler: () => void,
|
|
|
|
|
): void;
|
|
|
|
|
|
2020-04-13 10:46:34 -04:00
|
|
|
|
export type ProcessStatus =
|
|
|
|
|
| {
|
2020-07-14 15:24:17 -04:00
|
|
|
|
success: true;
|
|
|
|
|
code: 0;
|
|
|
|
|
signal?: undefined;
|
|
|
|
|
}
|
2020-04-13 10:46:34 -04:00
|
|
|
|
| {
|
2020-07-14 15:24:17 -04:00
|
|
|
|
success: false;
|
|
|
|
|
code: number;
|
|
|
|
|
signal?: number;
|
|
|
|
|
};
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Sub Process */
|
2020-01-17 19:01:24 -05:00
|
|
|
|
export interface RunOptions {
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Arguments to pass. Note, the first element needs to be a path to the
|
|
|
|
|
* binary */
|
2022-03-25 08:17:13 -04:00
|
|
|
|
cmd: readonly string[] | [URL, ...string[]];
|
2020-01-17 19:01:24 -05:00
|
|
|
|
cwd?: string;
|
|
|
|
|
env?: {
|
|
|
|
|
[key: string]: string;
|
|
|
|
|
};
|
2020-05-05 16:54:25 -04:00
|
|
|
|
stdout?: "inherit" | "piped" | "null" | number;
|
|
|
|
|
stderr?: "inherit" | "piped" | "null" | number;
|
|
|
|
|
stdin?: "inherit" | "piped" | "null" | number;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-30 19:44:16 -04:00
|
|
|
|
/** Spawns new subprocess. RunOptions must contain at a minimum the `opt.cmd`,
|
2020-03-31 23:21:37 -04:00
|
|
|
|
* an array of program arguments, the first of which is the binary.
|
2019-08-30 11:11:33 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* const p = Deno.run({
|
2022-05-30 19:44:16 -04:00
|
|
|
|
* cmd: ["curl", "https://example.com"],
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* });
|
2022-05-30 19:44:16 -04:00
|
|
|
|
* const status = await p.status();
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```
|
2020-05-05 16:54:25 -04:00
|
|
|
|
*
|
2019-08-30 11:11:33 -04:00
|
|
|
|
* Subprocess uses same working directory as parent process unless `opt.cwd`
|
|
|
|
|
* is specified.
|
|
|
|
|
*
|
2021-08-04 15:47:43 -04:00
|
|
|
|
* Environmental variables from parent process can be cleared using `opt.clearEnv`.
|
|
|
|
|
* Doesn't guarantee that only `opt.env` variables are present,
|
|
|
|
|
* as the OS may set environmental variables for processes.
|
|
|
|
|
*
|
2019-08-30 11:11:33 -04:00
|
|
|
|
* Environmental variables for subprocess can be specified using `opt.env`
|
|
|
|
|
* mapping.
|
|
|
|
|
*
|
2021-09-13 13:26:23 -04:00
|
|
|
|
* `opt.uid` sets the child process’s user ID. This translates to a setuid call
|
|
|
|
|
* in the child process. Failure in the setuid call will cause the spawn to fail.
|
|
|
|
|
*
|
|
|
|
|
* `opt.gid` is similar to `opt.uid`, but sets the group ID of the child process.
|
|
|
|
|
* This has the same semantics as the uid field.
|
|
|
|
|
*
|
2019-08-30 11:11:33 -04:00
|
|
|
|
* By default subprocess inherits stdio of parent process. To change that
|
|
|
|
|
* `opt.stdout`, `opt.stderr` and `opt.stdin` can be specified independently -
|
2020-05-05 16:54:25 -04:00
|
|
|
|
* they can be set to either an rid of open file or set to "inherit" "piped"
|
|
|
|
|
* or "null":
|
2020-02-28 11:05:40 -05:00
|
|
|
|
*
|
2020-05-05 16:54:25 -04:00
|
|
|
|
* `"inherit"` The default if unspecified. The child inherits from the
|
|
|
|
|
* corresponding parent descriptor.
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2020-05-05 16:54:25 -04:00
|
|
|
|
* `"piped"` A new pipe should be arranged to connect the parent and child
|
|
|
|
|
* sub-processes.
|
|
|
|
|
*
|
|
|
|
|
* `"null"` This stream will be ignored. This is the equivalent of attaching
|
|
|
|
|
* the stream to `/dev/null`.
|
|
|
|
|
*
|
|
|
|
|
* Details of the spawned process are returned.
|
2020-03-31 23:21:37 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-run` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-run
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category Sub Process
|
|
|
|
|
*/
|
2020-06-09 07:18:18 -04:00
|
|
|
|
export function run<T extends RunOptions = RunOptions>(opt: T): Process<T>;
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Console and Debugging */
|
2020-07-11 00:52:18 -04:00
|
|
|
|
export interface InspectOptions {
|
2020-09-29 22:59:50 -04:00
|
|
|
|
/** Stylize output with ANSI colors. Defaults to false. */
|
|
|
|
|
colors?: boolean;
|
2020-07-11 00:52:18 -04:00
|
|
|
|
/** Try to fit more than one entry of a collection on the same line.
|
|
|
|
|
* Defaults to true. */
|
|
|
|
|
compact?: boolean;
|
2020-09-29 22:59:50 -04:00
|
|
|
|
/** Traversal depth for nested objects. Defaults to 4. */
|
|
|
|
|
depth?: number;
|
2020-07-11 00:52:18 -04:00
|
|
|
|
/** The maximum number of iterable entries to print. Defaults to 100. */
|
|
|
|
|
iterableLimit?: number;
|
2020-09-08 10:06:26 -04:00
|
|
|
|
/** Show a Proxy's target and handler. Defaults to false. */
|
|
|
|
|
showProxy?: boolean;
|
2020-09-29 22:59:50 -04:00
|
|
|
|
/** Sort Object, Set and Map entries by key. Defaults to false. */
|
|
|
|
|
sorted?: boolean;
|
|
|
|
|
/** Add a trailing comma for multiline collections. Defaults to false. */
|
|
|
|
|
trailingComma?: boolean;
|
2020-10-11 15:52:20 -04:00
|
|
|
|
/*** Evaluate the result of calling getters. Defaults to false. */
|
|
|
|
|
getters?: boolean;
|
2021-02-10 06:52:54 -05:00
|
|
|
|
/** Show an object's non-enumerable properties. Defaults to false. */
|
|
|
|
|
showHidden?: boolean;
|
2022-04-25 07:59:15 -04:00
|
|
|
|
/** The maximum length of a string before it is truncated with an ellipsis */
|
|
|
|
|
strAbbreviateSize?: number;
|
2020-02-28 11:05:40 -05:00
|
|
|
|
}
|
2020-01-17 19:01:24 -05:00
|
|
|
|
|
2020-04-28 14:11:50 -04:00
|
|
|
|
/** Converts the input into a string that has the same format as printed by
|
2020-03-25 20:48:47 -04:00
|
|
|
|
* `console.log()`.
|
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
2021-05-10 22:17:07 -04:00
|
|
|
|
* const obj = {
|
|
|
|
|
* a: 10,
|
|
|
|
|
* b: "hello",
|
|
|
|
|
* };
|
|
|
|
|
* const objAsString = Deno.inspect(obj); // { a: 10, b: "hello" }
|
|
|
|
|
* console.log(obj); // prints same value as objAsString, e.g. { a: 10, b: "hello" }
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```
|
2020-03-25 20:48:47 -04:00
|
|
|
|
*
|
2021-06-25 03:19:18 -04:00
|
|
|
|
* You can also register custom inspect functions, via the symbol `Symbol.for("Deno.customInspect")`,
|
|
|
|
|
* on objects, to control and customize the output.
|
2020-03-25 20:48:47 -04:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* class A {
|
|
|
|
|
* x = 10;
|
|
|
|
|
* y = "hello";
|
2021-06-25 03:19:18 -04:00
|
|
|
|
* [Symbol.for("Deno.customInspect")](): string {
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* return "x=" + this.x + ", y=" + this.y;
|
|
|
|
|
* }
|
|
|
|
|
* }
|
2020-03-25 20:48:47 -04:00
|
|
|
|
*
|
2021-05-10 22:17:07 -04:00
|
|
|
|
* const inStringFormat = Deno.inspect(new A()); // "x=10, y=hello"
|
|
|
|
|
* console.log(inStringFormat); // prints "x=10, y=hello"
|
|
|
|
|
* ```
|
2020-03-25 20:48:47 -04:00
|
|
|
|
*
|
2020-06-12 08:40:32 -04:00
|
|
|
|
* Finally, you can also specify the depth to which it will format.
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2021-05-10 22:17:07 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.inspect({a: {b: {c: {d: 'hello'}}}}, {depth: 2}); // { a: { b: [Object] } }
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Console and Debugging
|
2020-03-25 20:48:47 -04:00
|
|
|
|
*/
|
|
|
|
|
export function inspect(value: unknown, options?: InspectOptions): string;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** The name of a "powerful feature" which needs permission.
|
|
|
|
|
*
|
|
|
|
|
* @category Permissions
|
|
|
|
|
*/
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export type PermissionName =
|
|
|
|
|
| "run"
|
|
|
|
|
| "read"
|
|
|
|
|
| "write"
|
|
|
|
|
| "net"
|
|
|
|
|
| "env"
|
2021-08-06 17:28:10 -04:00
|
|
|
|
| "ffi"
|
2021-02-24 22:33:09 -05:00
|
|
|
|
| "hrtime";
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** The current status of the permission.
|
|
|
|
|
*
|
|
|
|
|
* @category Permissions
|
|
|
|
|
*/
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export type PermissionState = "granted" | "denied" | "prompt";
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface RunPermissionDescriptor {
|
|
|
|
|
name: "run";
|
2021-08-06 09:04:00 -04:00
|
|
|
|
command?: string | URL;
|
2021-02-24 22:33:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface ReadPermissionDescriptor {
|
|
|
|
|
name: "read";
|
2021-08-06 09:04:00 -04:00
|
|
|
|
path?: string | URL;
|
2021-02-24 22:33:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface WritePermissionDescriptor {
|
|
|
|
|
name: "write";
|
2021-08-06 09:04:00 -04:00
|
|
|
|
path?: string | URL;
|
2021-02-24 22:33:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface NetPermissionDescriptor {
|
|
|
|
|
name: "net";
|
|
|
|
|
/** Optional host string of the form `"<hostname>[:<port>]"`. Examples:
|
|
|
|
|
*
|
|
|
|
|
* "github.com"
|
|
|
|
|
* "deno.land:8080"
|
|
|
|
|
*/
|
2021-08-06 15:10:04 -04:00
|
|
|
|
host?: string;
|
2021-02-24 22:33:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface EnvPermissionDescriptor {
|
|
|
|
|
name: "env";
|
2021-04-13 07:25:21 -04:00
|
|
|
|
variable?: string;
|
2021-02-24 22:33:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-08-24 09:08:41 -04:00
|
|
|
|
export interface FfiPermissionDescriptor {
|
2021-08-06 17:28:10 -04:00
|
|
|
|
name: "ffi";
|
2021-10-13 13:04:44 -04:00
|
|
|
|
path?: string | URL;
|
2021-02-24 22:33:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface HrtimePermissionDescriptor {
|
|
|
|
|
name: "hrtime";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** Permission descriptors which define a permission and can be queried,
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* requested, or revoked.
|
|
|
|
|
*
|
|
|
|
|
* @category Permissions
|
|
|
|
|
*/
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export type PermissionDescriptor =
|
|
|
|
|
| RunPermissionDescriptor
|
|
|
|
|
| ReadPermissionDescriptor
|
|
|
|
|
| WritePermissionDescriptor
|
|
|
|
|
| NetPermissionDescriptor
|
|
|
|
|
| EnvPermissionDescriptor
|
2021-08-24 09:08:41 -04:00
|
|
|
|
| FfiPermissionDescriptor
|
2021-02-24 22:33:09 -05:00
|
|
|
|
| HrtimePermissionDescriptor;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export interface PermissionStatusEventMap {
|
|
|
|
|
"change": Event;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export class PermissionStatus extends EventTarget {
|
|
|
|
|
// deno-lint-ignore no-explicit-any
|
|
|
|
|
onchange: ((this: PermissionStatus, ev: Event) => any) | null;
|
|
|
|
|
readonly state: PermissionState;
|
|
|
|
|
addEventListener<K extends keyof PermissionStatusEventMap>(
|
|
|
|
|
type: K,
|
|
|
|
|
listener: (
|
|
|
|
|
this: PermissionStatus,
|
|
|
|
|
ev: PermissionStatusEventMap[K],
|
|
|
|
|
) => any,
|
|
|
|
|
options?: boolean | AddEventListenerOptions,
|
|
|
|
|
): void;
|
|
|
|
|
addEventListener(
|
|
|
|
|
type: string,
|
|
|
|
|
listener: EventListenerOrEventListenerObject,
|
|
|
|
|
options?: boolean | AddEventListenerOptions,
|
|
|
|
|
): void;
|
|
|
|
|
removeEventListener<K extends keyof PermissionStatusEventMap>(
|
|
|
|
|
type: K,
|
|
|
|
|
listener: (
|
|
|
|
|
this: PermissionStatus,
|
|
|
|
|
ev: PermissionStatusEventMap[K],
|
|
|
|
|
) => any,
|
|
|
|
|
options?: boolean | EventListenerOptions,
|
|
|
|
|
): void;
|
|
|
|
|
removeEventListener(
|
|
|
|
|
type: string,
|
|
|
|
|
listener: EventListenerOrEventListenerObject,
|
|
|
|
|
options?: boolean | EventListenerOptions,
|
|
|
|
|
): void;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Permissions */
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export class Permissions {
|
|
|
|
|
/** Resolves to the current status of a permission.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* const status = await Deno.permissions.query({ name: "read", path: "/etc" });
|
2021-05-11 01:44:15 -04:00
|
|
|
|
* console.log(status.state);
|
2021-02-24 22:33:09 -05:00
|
|
|
|
* ```
|
|
|
|
|
*/
|
|
|
|
|
query(desc: PermissionDescriptor): Promise<PermissionStatus>;
|
|
|
|
|
|
|
|
|
|
/** Revokes a permission, and resolves to the state of the permission.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2021-05-05 01:50:38 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2021-05-11 01:44:15 -04:00
|
|
|
|
*
|
2021-02-24 22:33:09 -05:00
|
|
|
|
* const status = await Deno.permissions.revoke({ name: "run" });
|
|
|
|
|
* assert(status.state !== "granted")
|
|
|
|
|
* ```
|
|
|
|
|
*/
|
|
|
|
|
revoke(desc: PermissionDescriptor): Promise<PermissionStatus>;
|
|
|
|
|
|
|
|
|
|
/** Requests the permission, and resolves to the state of the permission.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* const status = await Deno.permissions.request({ name: "env" });
|
|
|
|
|
* if (status.state === "granted") {
|
|
|
|
|
* console.log("'env' permission is granted.");
|
|
|
|
|
* } else {
|
|
|
|
|
* console.log("'env' permission is denied.");
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
|
|
|
|
*/
|
|
|
|
|
request(desc: PermissionDescriptor): Promise<PermissionStatus>;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** Deno's permission management API.
|
|
|
|
|
*
|
|
|
|
|
* @category Permissions
|
|
|
|
|
*/
|
2021-02-24 22:33:09 -05:00
|
|
|
|
export const permissions: Permissions;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** Build related information.
|
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
|
|
|
|
*/
|
2020-04-28 12:35:23 -04:00
|
|
|
|
export const build: {
|
|
|
|
|
/** The LLVM target triple */
|
|
|
|
|
target: string;
|
|
|
|
|
/** Instruction set architecture */
|
2021-05-10 16:12:42 -04:00
|
|
|
|
arch: "x86_64" | "aarch64";
|
2020-04-28 12:35:23 -04:00
|
|
|
|
/** Operating system */
|
|
|
|
|
os: "darwin" | "linux" | "windows";
|
|
|
|
|
/** Computer vendor */
|
|
|
|
|
vendor: string;
|
|
|
|
|
/** Optional environment */
|
|
|
|
|
env?: string;
|
|
|
|
|
};
|
2019-08-30 11:11:33 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** Version related information.
|
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
|
|
|
|
*/
|
2020-11-16 14:36:00 -05:00
|
|
|
|
export const version: {
|
|
|
|
|
/** Deno's version. For example: `"1.0.0"` */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
deno: string;
|
2020-11-16 14:36:00 -05:00
|
|
|
|
/** The V8 version used by Deno. For example: `"8.0.0.0"` */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
v8: string;
|
2020-11-16 14:36:00 -05:00
|
|
|
|
/** The TypeScript version used by Deno. For example: `"4.0.0"` */
|
2019-08-30 11:11:33 -04:00
|
|
|
|
typescript: string;
|
2020-11-16 14:36:00 -05:00
|
|
|
|
};
|
2020-01-08 09:17:44 -05:00
|
|
|
|
|
2020-02-28 11:05:40 -05:00
|
|
|
|
/** Returns the script arguments to the program. If for example we run a
|
|
|
|
|
* program:
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* deno run --allow-read https://deno.land/std/examples/cat.ts /etc/passwd
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-02-28 11:05:40 -05:00
|
|
|
|
* Then `Deno.args` will contain:
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*
|
2020-05-16 15:23:48 -04:00
|
|
|
|
* [ "/etc/passwd" ]
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
2020-01-17 19:01:24 -05:00
|
|
|
|
*/
|
2019-08-30 11:11:33 -04:00
|
|
|
|
export const args: string[];
|
2020-01-16 19:42:58 -05:00
|
|
|
|
|
2021-06-25 03:19:18 -04:00
|
|
|
|
/**
|
2021-12-09 19:05:50 -05:00
|
|
|
|
* A symbol which can be used as a key for a custom method which will be
|
2020-04-27 19:06:03 -04:00
|
|
|
|
* called when `Deno.inspect()` is called, or when the object is logged to
|
2021-06-25 03:19:18 -04:00
|
|
|
|
* the console.
|
|
|
|
|
*
|
2021-12-09 19:05:50 -05:00
|
|
|
|
* @deprecated This symbol is deprecated since 1.9. Use
|
|
|
|
|
* `Symbol.for("Deno.customInspect")` instead.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Console and Debugging
|
2021-06-25 03:19:18 -04:00
|
|
|
|
*/
|
2020-04-27 19:06:03 -04:00
|
|
|
|
export const customInspect: unique symbol;
|
2020-08-10 16:41:51 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** The URL of the entrypoint module entered from the command-line.
|
|
|
|
|
*
|
|
|
|
|
* @category Runtime Environment
|
|
|
|
|
*/
|
2020-08-10 16:41:51 -04:00
|
|
|
|
export const mainModule: string;
|
2021-02-25 19:13:48 -05:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category File System */
|
2021-02-25 19:13:48 -05:00
|
|
|
|
export type SymlinkOptions = {
|
|
|
|
|
type: "file" | "dir";
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates `newpath` as a symbolic link to `oldpath`.
|
|
|
|
|
*
|
|
|
|
|
* The options.type parameter can be set to `file` or `dir`. This argument is only
|
|
|
|
|
* available on Windows and ignored on other platforms.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* Deno.symlinkSync("old/name", "new/name");
|
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires full `allow-read` and `allow-write` permissions.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-02-25 19:13:48 -05:00
|
|
|
|
export function symlinkSync(
|
2021-06-03 10:16:00 -04:00
|
|
|
|
oldpath: string | URL,
|
|
|
|
|
newpath: string | URL,
|
2021-02-25 19:13:48 -05:00
|
|
|
|
options?: SymlinkOptions,
|
|
|
|
|
): void;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates `newpath` as a symbolic link to `oldpath`.
|
|
|
|
|
*
|
|
|
|
|
* The options.type parameter can be set to `file` or `dir`. This argument is only
|
|
|
|
|
* available on Windows and ignored on other platforms.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* await Deno.symlink("old/name", "new/name");
|
|
|
|
|
* ```
|
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires full `allow-read` and `allow-write` permissions.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-read, allow-write
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category File System
|
|
|
|
|
*/
|
2021-02-25 19:13:48 -05:00
|
|
|
|
export function symlink(
|
2021-06-03 10:16:00 -04:00
|
|
|
|
oldpath: string | URL,
|
|
|
|
|
newpath: string | URL,
|
2021-02-25 19:13:48 -05:00
|
|
|
|
options?: SymlinkOptions,
|
|
|
|
|
): Promise<void>;
|
2021-04-11 08:05:22 -04:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Synchronously truncates or extends the specified file stream, to reach the
|
|
|
|
|
* specified `len`.
|
|
|
|
|
*
|
|
|
|
|
* If `len` is not specified then the entire file contents are truncated as if len was set to 0.
|
|
|
|
|
*
|
|
|
|
|
* if the file previously was larger than this new length, the extra data is lost.
|
|
|
|
|
*
|
|
|
|
|
* if the file previously was shorter, it is extended, and the extended part reads as null bytes ('\0').
|
2021-04-25 23:59:22 -04:00
|
|
|
|
*
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* ```ts
|
|
|
|
|
* // truncate the entire file
|
2021-05-04 03:47:11 -04:00
|
|
|
|
* const file = Deno.openSync("my_file.txt", { read: true, write: true, truncate: true, create: true });
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* Deno.ftruncateSync(file.rid);
|
2021-05-04 23:45:10 -04:00
|
|
|
|
* ```
|
2021-04-11 08:05:22 -04:00
|
|
|
|
*
|
2021-05-04 23:45:10 -04:00
|
|
|
|
* ```ts
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* // truncate part of the file
|
2021-04-27 05:23:18 -04:00
|
|
|
|
* const file = Deno.openSync("my_file.txt", { read: true, write: true, create: true });
|
|
|
|
|
* Deno.writeSync(file.rid, new TextEncoder().encode("Hello World"));
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* Deno.ftruncateSync(file.rid, 7);
|
2021-04-27 05:23:18 -04:00
|
|
|
|
* Deno.seekSync(file.rid, 0, Deno.SeekMode.Start);
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* const data = new Uint8Array(32);
|
|
|
|
|
* Deno.readSync(file.rid, data);
|
|
|
|
|
* console.log(new TextDecoder().decode(data)); // Hello W
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category File System
|
2021-04-11 08:05:22 -04:00
|
|
|
|
*/
|
|
|
|
|
export function ftruncateSync(rid: number, len?: number): void;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Truncates or extends the specified file stream, to reach the specified `len`.
|
|
|
|
|
*
|
|
|
|
|
* If `len` is not specified then the entire file contents are truncated as if len was set to 0.
|
|
|
|
|
*
|
|
|
|
|
* If the file previously was larger than this new length, the extra data is lost.
|
|
|
|
|
*
|
|
|
|
|
* If the file previously was shorter, it is extended, and the extended part reads as null bytes ('\0').
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* // truncate the entire file
|
2021-05-05 01:59:12 -04:00
|
|
|
|
* const file = await Deno.open("my_file.txt", { read: true, write: true, create: true });
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* await Deno.ftruncate(file.rid);
|
2021-05-04 23:45:10 -04:00
|
|
|
|
* ```
|
2021-04-11 08:05:22 -04:00
|
|
|
|
*
|
2021-05-04 23:45:10 -04:00
|
|
|
|
* ```ts
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* // truncate part of the file
|
2021-05-05 01:59:12 -04:00
|
|
|
|
* const file = await Deno.open("my_file.txt", { read: true, write: true, create: true });
|
2021-04-11 08:05:22 -04:00
|
|
|
|
* await Deno.write(file.rid, new TextEncoder().encode("Hello World"));
|
|
|
|
|
* await Deno.ftruncate(file.rid, 7);
|
|
|
|
|
* const data = new Uint8Array(32);
|
|
|
|
|
* await Deno.read(file.rid, data);
|
|
|
|
|
* console.log(new TextDecoder().decode(data)); // Hello W
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category File System
|
2021-04-11 08:05:22 -04:00
|
|
|
|
*/
|
|
|
|
|
export function ftruncate(rid: number, len?: number): Promise<void>;
|
2021-04-12 05:27:38 -04:00
|
|
|
|
|
2021-04-25 23:59:22 -04:00
|
|
|
|
/**
|
2021-04-12 05:27:38 -04:00
|
|
|
|
* Synchronously returns a `Deno.FileInfo` for the given file stream.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2021-05-05 01:50:38 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2021-04-12 05:27:38 -04:00
|
|
|
|
* const file = Deno.openSync("file.txt", { read: true });
|
|
|
|
|
* const fileInfo = Deno.fstatSync(file.rid);
|
|
|
|
|
* assert(fileInfo.isFile);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category File System
|
2021-04-12 05:27:38 -04:00
|
|
|
|
*/
|
|
|
|
|
export function fstatSync(rid: number): FileInfo;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns a `Deno.FileInfo` for the given file stream.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2021-05-05 01:50:38 -04:00
|
|
|
|
* import { assert } from "https://deno.land/std/testing/asserts.ts";
|
2021-04-12 05:27:38 -04:00
|
|
|
|
* const file = await Deno.open("file.txt", { read: true });
|
|
|
|
|
* const fileInfo = await Deno.fstat(file.rid);
|
|
|
|
|
* assert(fileInfo.isFile);
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category File System
|
2021-04-12 05:27:38 -04:00
|
|
|
|
*/
|
|
|
|
|
export function fstat(rid: number): Promise<FileInfo>;
|
2021-08-02 08:40:46 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category HTTP Server */
|
2021-08-02 08:40:46 -04:00
|
|
|
|
export interface RequestEvent {
|
|
|
|
|
readonly request: Request;
|
|
|
|
|
respondWith(r: Response | Promise<Response>): Promise<void>;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category HTTP Server */
|
2021-08-02 08:40:46 -04:00
|
|
|
|
export interface HttpConn extends AsyncIterable<RequestEvent> {
|
|
|
|
|
readonly rid: number;
|
|
|
|
|
|
|
|
|
|
nextRequest(): Promise<RequestEvent | null>;
|
|
|
|
|
close(): void;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Services HTTP requests given a TCP or TLS socket.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2022-06-11 13:06:58 -04:00
|
|
|
|
* const conn = Deno.listen({ port: 80 });
|
2021-09-24 06:14:12 -04:00
|
|
|
|
* const httpConn = Deno.serveHttp(await conn.accept());
|
2021-08-02 08:40:46 -04:00
|
|
|
|
* const e = await httpConn.nextRequest();
|
|
|
|
|
* if (e) {
|
|
|
|
|
* e.respondWith(new Response("Hello World"));
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* If `httpConn.nextRequest()` encounters an error or returns `null`
|
|
|
|
|
* then the underlying HttpConn resource is closed automatically.
|
2021-08-26 11:06:58 -04:00
|
|
|
|
*
|
|
|
|
|
* Alternatively, you can also use the Async Iterator approach:
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* async function handleHttp(conn: Deno.Conn) {
|
|
|
|
|
* for await (const e of Deno.serveHttp(conn)) {
|
|
|
|
|
* e.respondWith(new Response("Hello World"));
|
|
|
|
|
* }
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* for await (const conn of Deno.listen({ port: 80 })) {
|
|
|
|
|
* handleHttp(conn);
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category HTTP Server
|
2021-08-02 08:40:46 -04:00
|
|
|
|
*/
|
|
|
|
|
export function serveHttp(conn: Conn): HttpConn;
|
2021-09-13 08:06:12 -04:00
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Web Sockets */
|
2021-09-13 08:06:12 -04:00
|
|
|
|
export interface WebSocketUpgrade {
|
|
|
|
|
response: Response;
|
|
|
|
|
socket: WebSocket;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Web Sockets */
|
2021-09-13 08:06:12 -04:00
|
|
|
|
export interface UpgradeWebSocketOptions {
|
|
|
|
|
protocol?: string;
|
2022-01-06 11:41:16 -05:00
|
|
|
|
/**
|
|
|
|
|
* If the client does not respond to this frame with a
|
|
|
|
|
* `pong` within the timeout specified, the connection is deemed
|
|
|
|
|
* unhealthy and is closed. The `close` and `error` event will be emitted.
|
|
|
|
|
*
|
|
|
|
|
* The default is 120 seconds. Set to 0 to disable timeouts.
|
|
|
|
|
*/
|
|
|
|
|
idleTimeout?: number;
|
2021-09-13 08:06:12 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Used to upgrade an incoming HTTP request to a WebSocket.
|
|
|
|
|
*
|
|
|
|
|
* Given a request, returns a pair of WebSocket and Response. The original
|
|
|
|
|
* request must be responded to with the returned response for the websocket
|
|
|
|
|
* upgrade to be successful.
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
2022-06-11 13:06:58 -04:00
|
|
|
|
* const conn = Deno.listen({ port: 80 });
|
2021-09-24 06:14:12 -04:00
|
|
|
|
* const httpConn = Deno.serveHttp(await conn.accept());
|
2021-09-13 08:06:12 -04:00
|
|
|
|
* const e = await httpConn.nextRequest();
|
|
|
|
|
* if (e) {
|
|
|
|
|
* const { socket, response } = Deno.upgradeWebSocket(e.request);
|
|
|
|
|
* socket.onopen = () => {
|
|
|
|
|
* socket.send("Hello World!");
|
|
|
|
|
* };
|
|
|
|
|
* socket.onmessage = (e) => {
|
|
|
|
|
* console.log(e.data);
|
|
|
|
|
* socket.close();
|
|
|
|
|
* };
|
|
|
|
|
* socket.onclose = () => console.log("WebSocket has been closed.");
|
|
|
|
|
* socket.onerror = (e) => console.error("WebSocket error:", e);
|
|
|
|
|
* e.respondWith(response);
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* If the request body is disturbed (read from) before the upgrade is
|
|
|
|
|
* completed, upgrading fails.
|
|
|
|
|
*
|
|
|
|
|
* This operation does not yet consume the request or open the websocket. This
|
|
|
|
|
* only happens once the returned response has been passed to `respondWith`.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
|
|
|
|
* @category Web Sockets
|
2021-09-13 08:06:12 -04:00
|
|
|
|
*/
|
|
|
|
|
export function upgradeWebSocket(
|
|
|
|
|
request: Request,
|
|
|
|
|
options?: UpgradeWebSocketOptions,
|
|
|
|
|
): WebSocketUpgrade;
|
2021-10-10 06:16:11 -04:00
|
|
|
|
|
2021-10-10 09:48:26 -04:00
|
|
|
|
/** Send a signal to process under given `pid`.
|
|
|
|
|
*
|
|
|
|
|
* If `pid` is negative, the signal will be sent to the process group
|
2022-06-13 16:39:46 -04:00
|
|
|
|
* identified by `pid`. An error will be thrown if a negative
|
|
|
|
|
* `pid` is used on Windows.
|
2021-10-10 09:48:26 -04:00
|
|
|
|
*
|
2022-02-22 14:41:59 -05:00
|
|
|
|
* ```ts
|
|
|
|
|
* const p = Deno.run({
|
|
|
|
|
* cmd: ["sleep", "10000"]
|
|
|
|
|
* });
|
2021-10-10 09:48:26 -04:00
|
|
|
|
*
|
2022-02-22 14:41:59 -05:00
|
|
|
|
* Deno.kill(p.pid, "SIGINT");
|
|
|
|
|
* ```
|
2021-10-10 09:48:26 -04:00
|
|
|
|
*
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Requires `allow-run` permission.
|
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-run
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category Sub Process
|
|
|
|
|
*/
|
2021-10-10 09:48:26 -04:00
|
|
|
|
export function kill(pid: number, signo: Signal): void;
|
|
|
|
|
|
2021-10-10 06:16:11 -04:00
|
|
|
|
/** The type of the resource record.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* Only the listed types are supported currently.
|
|
|
|
|
*
|
|
|
|
|
* @category Network
|
|
|
|
|
*/
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export type RecordType =
|
|
|
|
|
| "A"
|
|
|
|
|
| "AAAA"
|
|
|
|
|
| "ANAME"
|
2022-05-16 05:20:41 -04:00
|
|
|
|
| "CAA"
|
2021-10-10 06:16:11 -04:00
|
|
|
|
| "CNAME"
|
|
|
|
|
| "MX"
|
2022-05-15 11:42:02 -04:00
|
|
|
|
| "NAPTR"
|
2022-05-03 14:04:20 -04:00
|
|
|
|
| "NS"
|
2021-10-10 06:16:11 -04:00
|
|
|
|
| "PTR"
|
2022-05-14 08:08:35 -04:00
|
|
|
|
| "SOA"
|
2021-10-10 06:16:11 -04:00
|
|
|
|
| "SRV"
|
|
|
|
|
| "TXT";
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export interface ResolveDnsOptions {
|
|
|
|
|
/** The name server to be used for lookups.
|
|
|
|
|
* If not specified, defaults to the system configuration e.g. `/etc/resolv.conf` on Unix. */
|
|
|
|
|
nameServer?: {
|
|
|
|
|
/** The IP address of the name server */
|
|
|
|
|
ipAddr: string;
|
|
|
|
|
/** The port number the query will be sent to.
|
|
|
|
|
* If not specified, defaults to 53. */
|
|
|
|
|
port?: number;
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** If `resolveDns` is called with "CAA" record type specified, it will return
|
|
|
|
|
* an array of this interface.
|
|
|
|
|
*
|
|
|
|
|
* @category Network
|
|
|
|
|
*/
|
2022-05-16 05:20:41 -04:00
|
|
|
|
export interface CAARecord {
|
|
|
|
|
critical: boolean;
|
|
|
|
|
tag: string;
|
|
|
|
|
value: string;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** If `resolveDns` is called with "MX" record type specified, it will return
|
|
|
|
|
* an array of this interface.
|
|
|
|
|
*
|
|
|
|
|
* @category Network
|
|
|
|
|
*/
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export interface MXRecord {
|
|
|
|
|
preference: number;
|
|
|
|
|
exchange: string;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** If `resolveDns` is called with "NAPTR" record type specified, it will
|
|
|
|
|
* return an array of this interface.
|
|
|
|
|
*
|
|
|
|
|
* @category Network
|
|
|
|
|
*/
|
2022-05-15 11:42:02 -04:00
|
|
|
|
export interface NAPTRRecord {
|
|
|
|
|
order: number;
|
|
|
|
|
preference: number;
|
|
|
|
|
flags: string;
|
|
|
|
|
services: string;
|
|
|
|
|
regexp: string;
|
|
|
|
|
replacement: string;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** If `resolveDns` is called with "SOA" record type specified, it will return
|
|
|
|
|
* an array of this interface.
|
|
|
|
|
*
|
|
|
|
|
* @category Network
|
|
|
|
|
*/
|
2022-05-14 08:08:35 -04:00
|
|
|
|
export interface SOARecord {
|
|
|
|
|
mname: string;
|
|
|
|
|
rname: string;
|
2022-05-15 10:43:08 -04:00
|
|
|
|
serial: number;
|
|
|
|
|
refresh: number;
|
|
|
|
|
retry: number;
|
|
|
|
|
expire: number;
|
|
|
|
|
minimum: number;
|
2022-05-14 08:08:35 -04:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** If `resolveDns` is called with "SRV" record type specified, it will return
|
|
|
|
|
* an array of this interface.
|
|
|
|
|
*
|
|
|
|
|
* @category Network
|
|
|
|
|
*/
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export interface SRVRecord {
|
|
|
|
|
priority: number;
|
|
|
|
|
weight: number;
|
|
|
|
|
port: number;
|
|
|
|
|
target: string;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
2022-05-03 14:04:20 -04:00
|
|
|
|
recordType: "A" | "AAAA" | "ANAME" | "CNAME" | "NS" | "PTR",
|
2021-10-10 06:16:11 -04:00
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<string[]>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2022-05-16 05:20:41 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: "CAA",
|
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<CAARecord[]>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: "MX",
|
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<MXRecord[]>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2022-05-15 11:42:02 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: "NAPTR",
|
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<NAPTRRecord[]>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2022-05-14 08:08:35 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: "SOA",
|
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<SOARecord[]>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: "SRV",
|
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<SRVRecord[]>;
|
|
|
|
|
|
2022-08-16 23:12:24 -04:00
|
|
|
|
/** @category Network */
|
2021-10-10 06:16:11 -04:00
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: "TXT",
|
|
|
|
|
options?: ResolveDnsOptions,
|
|
|
|
|
): Promise<string[][]>;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Performs DNS resolution against the given query, returning resolved records.
|
|
|
|
|
* Fails in the cases such as:
|
|
|
|
|
* - the query is in invalid format
|
|
|
|
|
* - the options have an invalid parameter, e.g. `nameServer.port` is beyond the range of 16-bit unsigned integer
|
|
|
|
|
* - timed out
|
|
|
|
|
*
|
|
|
|
|
* ```ts
|
|
|
|
|
* const a = await Deno.resolveDns("example.com", "A");
|
|
|
|
|
*
|
|
|
|
|
* const aaaa = await Deno.resolveDns("example.com", "AAAA", {
|
|
|
|
|
* nameServer: { ipAddr: "8.8.8.8", port: 53 },
|
|
|
|
|
* });
|
|
|
|
|
* ```
|
|
|
|
|
*
|
|
|
|
|
* Requires `allow-net` permission.
|
2022-08-16 23:12:24 -04:00
|
|
|
|
*
|
2022-08-22 20:57:01 -04:00
|
|
|
|
* @tags allow-net
|
2022-08-16 23:12:24 -04:00
|
|
|
|
* @category Network
|
2021-10-10 06:16:11 -04:00
|
|
|
|
*/
|
|
|
|
|
export function resolveDns(
|
|
|
|
|
query: string,
|
|
|
|
|
recordType: RecordType,
|
|
|
|
|
options?: ResolveDnsOptions,
|
2022-05-15 11:42:02 -04:00
|
|
|
|
): Promise<
|
|
|
|
|
| string[]
|
2022-05-16 05:20:41 -04:00
|
|
|
|
| CAARecord[]
|
2022-05-15 11:42:02 -04:00
|
|
|
|
| MXRecord[]
|
|
|
|
|
| NAPTRRecord[]
|
|
|
|
|
| SOARecord[]
|
|
|
|
|
| SRVRecord[]
|
|
|
|
|
| string[][]
|
|
|
|
|
>;
|
2019-08-30 11:11:33 -04:00
|
|
|
|
}
|