Crate deno_core[][src]

Re-exports

pub use futures;
pub use rusty_v8 as v8;
pub use serde;
pub use serde_json;
pub use url;

Modules

error
plugin_api

Structs

AsyncRefCell
CancelHandle
Canceled
FsModuleLoader

Basic file system module loader.

JsRuntime

A single execution context of JavaScript. Corresponds roughly to the “Web Worker” concept in the DOM. A JsRuntime is a Future that can be used with an event loop (Tokio, async_std). The JsRuntime future completes when there is an error or when all pending ops have completed.

ModuleSource

EsModule source code that will be loaded into V8.

NoopModuleLoader

Placeholder structure used when creating a runtime that doesn’t support module loading.

OpState

Maintains the resources and ops inside a JS runtime.

OpTable

Collection for storing registered ops. The special ‘get_op_catalog’ op with OpId 0 is automatically added when the OpTable is created.

RcRef

An RcRef encapsulates a reference counted pointer, just like a regular std::rc::Rc. However, unlike a regular Rc, it can be remapped so that it dereferences to any value that’s reachable through the reference-counted pointer. This is achieved through the associated method, RcRef::map(), similar to how std::cell::Ref::map() works. Example:

RecursiveModuleLoad

This future is used to implement parallel async module loading.

ResourceTable

Map-like data structure storing Deno’s resources (equivalent to file descriptors).

RuntimeOptions
TryCancelable
ZeroCopyBuf

A ZeroCopyBuf encapsulates a slice that’s been borrowed from a JavaScript ArrayBuffer object. JavaScript objects can normally be garbage collected, but the existence of a ZeroCopyBuf inhibits this until it is dropped. It behaves much like an Arc<u8>.

Enums

Cancelable
ModuleResolutionError

Error indicating the reason resolving a module specifier failed.

Op
Snapshot

Constants

DUMMY_SPECIFIER

Traits

CancelFuture
CancelTryFuture
ModuleLoader
RcLike

The RcLike trait provides an abstraction over std::rc::Rc and RcRef, so that applicable methods can operate on either type.

Resource

All objects that can be store in the resource table should implement the Resource trait.

ValueOrVector

Functions

bin_op_async

Creates an op that passes data asynchronously using raw ui8 buffer.

bin_op_sync

Creates an op that passes data synchronously using raw ui8 buffer.

json_op_async

Creates an op that passes data asynchronously using JSON.

json_op_sync

Creates an op that passes data synchronously using JSON.

normalize_path

Normalize all intermediate components of the path (ie. remove “./” and “../” components). Similar to fs::canonicalize() but doesn’t resolve symlinks.

op_close

Remove a resource from the resource table.

op_resources

Return map of resources with id as key and string representation as value.

resolve_import

Resolves module using this algorithm: https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-module-specifier

resolve_path

Converts a string representing a relative or absolute path into a ModuleSpecifier. A relative path is considered relative to the current working directory.

resolve_url

Converts a string representing an absolute URL into a ModuleSpecifier.

resolve_url_or_path

Takes a string representing either an absolute URL or a file path, as it may be passed to deno as a command line argument. The string is interpreted as a URL if it starts with a valid URI scheme, e.g. ‘http:’ or ‘file:’ or ‘git+ssh:’. If not, it’s interpreted as a file path; if it is a relative path it’s resolved relative to the current working directory.

v8_set_flags

Pass the command line arguments to v8. Returns a vector of command line arguments that V8 did not understand.

v8_version

Type Definitions

AsyncMut
AsyncMutFuture
AsyncRef
AsyncRefFuture
BufVec
GetErrorClassFn
JsErrorCreateFn
ModuleId
ModuleLoadId
ModuleSourceFuture
ModuleSpecifier

Resolved module specifier

OpAsyncFuture
OpFn
OpId
ResourceId

A ResourceId is an integer value referencing a resource. It could be considered to be the Deno equivalent of a file descriptor in POSIX like operating systems. Elsewhere in the code base it is commonly abbreviated to rid.