File and Directory Entries API

Editor’s Draft,

This version:
https://wicg.github.io/entries-api/
Test Suite:
https://github.com/w3c/web-platform-tests/tree/master/entries-api
Issue Tracking:
GitHub
Inline In Spec
Editor:

Abstract

This specification documents web browser support for file and directory upload by drag-and-drop operations. It introduces types representing directories with methods for asynchronous traversal, and extends HTMLInputElement and DataTransferItem [HTML].

Status of this document

This specification was published by the Web Platform Incubator Community Group. It is not a W3C Standard nor is it on the W3C Standards Track. Please note that under the W3C Community Contributor License Agreement (CLA) there is a limited opt-out and other conditions apply. Learn more about W3C Community and Business Groups.

1. Goals

This specification documents the types and operations made available by web browsers to script when a hierarchy of files and directories are dragged and dropped onto a page or selected using form elements, or equivalent user actions.

This is heavily based upon earlier drafts of [file-system-api] which defines similar types in the context of a sandboxed file system, including operations for creating and modifying files and directories, but which has not been broadly adopted by web browsers.

2. Concepts

2.1. Names and Paths

A name is a string which:

A path segment is a name, '.' (U+002E FULL STOP) or '..' (U+002E FULL STOP, U+002E FULL STOP).

A relative path is a string consisting of one or more path segments joined by '/' (U+002F SOLIDUS) that does not start with '/' (U+002F SOLIDUS).

An absolute path is a string consisting of '/' (U+002F SOLIDUS) followed by zero or more path segments joined by '/' (U+002F SOLIDUS).

A path is either a relative path or an absolute path.

A valid path is a USVString which is a path.

2.2. Files and Directories

A file consists of binary data and a name (a non-empty name).

A directory consists of a name (a name) and an ordered list of members. Each member is either a file or a directory. Each member of a directory must have a distinct non-empty name.

A root directory is a directory that is not a member of a directory. A root directory's name is empty.

The parent of a file or directory is the directory it is a member of. A root directory has no parent.

A file system consists of a name and a root which is an associated root directory. The name of a file system is a USVString which is implementation defined but is unique to the file system. A root directory is associated with exactly one file system.

2.3. Entries

An entry is either a file entry or a directory entry.

An entry has an name (a name) and a full path (an absolute path).

An entry also has a root, which is an associated root directory.

The file system of an entry is the file system associated with the entry's root.

2.4. Directory Reader

A directory reader consists of an associated directory entry, an associated directory (initially null), a reading flag (initially unset), a done flag (initially unset), and a reader error (initially null).

3. Algorithms

To resolve a relative path with abspath (an absolute path) and path (an absolute path, a relative path, or the empty string), run the following steps which return an absolute path:

  1. If path is an absolute path, return path.

  2. Let abspath segments be the result of strictly splitting abspath on '/' (U+002F SOLIDUS).

  3. Let path segments be the result of strictly splitting path on '/' (U+002F SOLIDUS).

  4. For each segment in path segments, switch on segment:

    empty string
    Continue.
    '.' (U+002E FULL STOP)
    Continue.
    '..' (U+002E FULL STOP, U+002E FULL STOP)
    Remove the last member of abspath segments unless it is the only member.
    Otherwise
    Append segment to abspath segments.
  1. Return abspath segments joined by '/' (U+002F SOLIDUS).

To evaluate a path with directory (an root directory) and path (an absolute path), run the following steps which return a file, directory, or failure.

  1. Let segments be the result of strictly splitting path on '/' (U+002F SOLIDUS).

  2. Remove the first entry from segments.

  3. For each segment in segments, switch on segment:

    empty string
    Continue.
    '.' (U+002E FULL STOP)
    Continue.
    '..' (U+002E FULL STOP, U+002E FULL STOP)
    Let directory be directory’s parent, or directory if none.
    Otherwise
    Run these substeps:
    1. Let item be the member of directory with name equal to segment, or return failure if none.

    2. If segment is the last item in segments, return item.

    3. If item is a file, return failure.

    4. Let directory be item.

4. The File Interface

partial interface File {
    readonly attribute USVString webkitRelativePath;
};

The webkitRelativePath attribute of the File interface must return the relative path of the file, or the empty string if not specified.

5. HTML: Forms

partial interface HTMLInputElement {
    attribute boolean webkitdirectory;
    readonly attribute FrozenArray<FileSystemEntry> webkitEntries;
};

When an input element’s type attribute is in the File Upload state, the rules in this section apply.

The webkitdirectory attribute is a boolean attribute that indicates whether the user is to be allowed to select a directory rather than a file or files. When specified, the behavior on the selection of a directory is as if all files with that directory as an ancestor were selected. In addition, the webkitRelativePath property of each File is set to a relative path from the shortest common ancestor directory of all selected files to that file, including that ancestor in the path. (Therefore this may be a subdirectory of the selected directory rather than the directory itself.)

The webkitEntries IDL attribute allows scripts to access the element’s selected entries. On getting, if the IDL attribute applies, it must return an array of FileSystemEntry objects that represent the current selected files (including directories, if permitted). If the IDL attribute does not apply, then it must instead return null.

6. HTML: Drag and drop

During a drag-and-drop operation, file and directory items are associated with entries. Each entry is a member of a root directory unique to the drag data store.

Additionally, each directory item is represented in the drag data store item list as a File. If it is accessed via getAsFile() a zero-length File is returned.

partial interface DataTransferItem {
    FileSystemEntry? webkitGetAsEntry();
};

The webkitGetAsEntry() method must run the following steps when invoked:

  1. If the DataTransferItem object is not in the read/write mode or the read-only mode, return null and abort these steps.

  2. If the drag data item kind is not File, then return null and abort these steps.

  3. Return a new FileSystemEntry object representing the entry.

7. Files and Directories

callback interface ErrorCallback {
    void handleEvent(DOMException err);
};

An ErrorCallback function is used for operations that may return an error asynchronously.

7.1. The FileSystemEntry Interface

interface FileSystemEntry {
    readonly attribute boolean isFile;
    readonly attribute boolean isDirectory;
    readonly attribute USVString name;
    readonly attribute USVString fullPath;
    readonly attribute FileSystem filesystem;

    void getParent(optional FileSystemEntryCallback successCallback,
                   optional ErrorCallback errorCallback);
};

An FileSystemEntry has an associated entry.

The isFile attribute of the FileSystemEntry interface must return true if the entry is a file entry and false otherwise.

The isDirectory attribute of the FileSystemEntry interface must return true if the entry is a directory entry and false otherwise.

The name attribute of the FileSystemEntry interface must return the name of the entry.

The fullPath attribute of the FileSystemEntry interface must return the full path of the entry.

The filesystem attribute of the FileSystemEntry interface must return the file system of the entry.

The getParent(successCallback, errorCallback) method, when invoked, must run the following steps:

  1. Queue a task to perform the following substeps:

    1. Let path be the result of running the steps to resolve a relative path with the entry's full path and '..'.

    2. Let item be the result of running the steps to evaluate a path with the entry's root and path.

    3. If item is failure, invoke the callback errorCallback (if given) with a newly created "NotFoundError" DOMException, and terminate these steps.

    4. Let entry be a new directory entry with item’s name as name and path as full path.

    5. Invoke the callback successCallback with a new FileSystemDirectoryEntry object associated with entry.

7.2. The FileSystemDirectoryEntry Interface

interface FileSystemDirectoryEntry : FileSystemEntry {
    FileSystemDirectoryReader createReader();
    void getFile(optional USVString? path,
                 optional FileSystemFlags options,
                 optional FileSystemEntryCallback successCallback,
                 optional ErrorCallback errorCallback);
    void getDirectory(optional USVString? path,
                      optional FileSystemFlags options,
                      optional FileSystemEntryCallback successCallback,
                      optional ErrorCallback errorCallback);
};

dictionary FileSystemFlags {
    boolean create = false;
    boolean exclusive = false;
};

callback interface FileSystemEntryCallback {
    void handleEvent(FileSystemEntry entry);
};

A FileSystemDirectoryEntry's associated entry is a directory entry.

The createReader() method, when invoked, must run the following steps:

  1. Let reader be a new directory reader associated with the directory entry's directory.

  2. Return a newly created FileSystemDirectoryReader object associated with reader.

The getFile(path, options, successCallback, errorCallback) method, when invoked, must run the following steps:

  1. Queue a task to run the following substeps:

    1. If path is undefined or null let path be the empty string.

    2. If path is not a valid path, invoke the callback errorCallback (if given) with a newly created "TypeMismatchError" DOMException, and terminate these steps.

    3. If options’s create member is true, invoke the callback errorCallback (if given) with a newly created "SecurityError" DOMException, and terminate these steps.

    4. Let path be the result of running the steps to resolve a relative path with the directory entry's full path and path.

    5. Let item be the result of running the steps to evaluate a path with the directory entry's root and path.

    6. If item is failure, invoke the callback errorCallback (if given) with a newly created "NotFoundError" DOMException, and terminate these steps.

    7. If item is not a file, invoke the callback errorCallback (if given) with a newly created "TypeMismatchError" DOMException, and terminate these steps.

    8. Let entry be a new file entry with item’s name as name and path as full path.

    9. Invoke the callback successCallback (if given) with a new FileSystemFileEntry object associated with entry.

The getDirectory(path, options, successCallback, errorCallback) method, when invoked, must run the following steps:

  1. Queue a task to run the following substeps:

    1. If path is undefined or null let path be the empty string.

    2. If path is not a valid path, invoke the callback errorCallback (if given) with a newly created "TypeMismatchError" DOMException, and terminate these steps.

    3. If options’s create member is true, invoke the callback errorCallback (if given) with a newly created "SecurityError" DOMException, and terminate these steps.

    4. Let path be the result of running the steps to resolve a relative path with the directory entry's full path and path.

    5. Let item be the result of running the steps to evaluate a path with the directory entry's root and path.

    6. If item is failure, invoke the callback errorCallback (if given) with a newly created "NotFoundError" DOMException, and terminate these steps.

    7. If item is not a directory, invoke the callback errorCallback (if given) with a newly created "TypeMismatchError" DOMException, and terminate these steps.

    8. Let entry be a new directory entry with item’s name as name and path as full path.

    9. Invoke the callback successCallback (if given) with a new FileSystemDirectoryEntry associated with entry.

7.3. The FileSystemDirectoryReader Interface

interface FileSystemDirectoryReader {
    void readEntries(FileSystemEntriesCallback successCallback,
                     optional ErrorCallback errorCallback);
};
callback interface FileSystemEntriesCallback {
    void handleEvent(sequence<FileSystemEntry> entries);
};

A FileSystemDirectoryReader has an associated directory reader.

The readEntries(successCallback, errorCallback) method, when invoked, must run the following steps:

  1. If the directory reader's reading flag is set, queue a task to invoke the callback errorCallback with a newly created "InvalidStateError" DOMException, and terminate these steps.

  2. If the directory reader's reader error is not null, queue a task to invoke the callback errorCallback (if given) with reader error, and terminate these steps.

  3. If the directory reader's done flag is set, queue a task to invoke the callback successCallback with an empty sequence and terminate these steps.

  4. Set the directory reader's reading flag.

  5. Queue a task to perform the following substeps:

    1. Clear the directory reader's reading flag.

    2. Let dir be the directory reader's directory.

    3. If dir is null, run these substeps:

      1. Let dir be the result of running the steps to evaluate a path with the entry's root and full path.

      2. If dir is failure, set the directory reader's reader error to a newly created "NotFoundError" DOMException, invoke the callback errorCallback (if given) with reader error, and terminate these steps.

      3. Set the directory reader's directory to dir.

    4. Let entries be a non-zero number of entries from the dir that have not yet been produced by this directory reader, if any.

    5. If the previous step failed (for example, the directory was deleted or permission is denied), then set the directory reader's reader error to an appropriate DOMException, invoke the callback errorCallback (if given) with reader error, and terminate these steps.

    6. If entries is empty, set the directory reader's done flag.

    7. Invoke the callback successCallback with entries.

7.4. The FileSystemFileEntry Interface

interface FileSystemFileEntry : FileSystemEntry {
    void file(FileCallback successCallback,
              optional ErrorCallback errorCallback);
};
callback interface FileCallback {
    void handleEvent(File file);
};

A FileSystemFileEntry's associated entry is a file entry.

The file(successCallback, errorCallback) method, when invoked, must run the following steps:

  1. Queue a task to perform the following substeps:

    1. Let item be the result of running the steps to evaluate a path with the file entry's root and full path.

    2. If item is failure, invoke the callback errorCallback (if given) with a newly created "NotFoundError" DOMException, and terminate these steps.

    3. If item is a directory, invoke the callback errorCallback (if given) with a newly created "TypeMismatchError" DOMException, and terminate these steps.

    4. Invoke the callback successCallback with a new File object representing item.

7.5. The FileSystem Interface

interface FileSystem {
    readonly attribute USVString name;
    readonly attribute FileSystemDirectoryEntry root;
};

A FileSystem has an associated file system.

The name attribute of the FileSystem interface must return the name of the file system.

The root attribute of the FileSystem interface must return a FileSystemDirectoryEntry associated with the root of the file system.

8. Acknowledgements

This specification is based heavily on the work of Eric Uhrhane in [file-system-api], which introduced the FileSystemEntry types.

Thanks to Tab Atkins, Jr. for creating and maintaining Bikeshed, the specification authoring tool used to create this document.

And thanks to Ali Alabbas, Philip Jägenstedt, Marijn Kruisselbrink, and Olli Pettay for suggestions, reviews, and other feedback.

Conformance

Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.

All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [RFC2119]

Examples in this specification are introduced with the words “for example” or are set apart from the normative text with class="example", like this:

This is an example of an informative example.

Informative notes begin with the word “Note” and are set apart from the normative text with class="note", like this:

Note, this is an informative note.

Index

Terms defined by this specification

Terms defined by reference

References

Normative References

[HTML]
Anne van Kesteren; et al. HTML Standard. Living Standard. URL: https://html.spec.whatwg.org/multipage/
[RFC2119]
S. Bradner. Key words for use in RFCs to Indicate Requirement Levels. March 1997. Best Current Practice. URL: https://tools.ietf.org/html/rfc2119
[WebIDL]
Cameron McCormack; Boris Zbarsky; Tobie Langel. Web IDL. URL: https://heycam.github.io/webidl/

Informative References

[ECMA-262]
ECMAScript Language Specification. URL: https://tc39.github.io/ecma262/
[FILE-SYSTEM-API]
Eric Uhrhane. File API: Directories and System. URL: https://www.w3.org/TR/file-system-api/
[FileAPI]
Arun Ranganathan; Jonas Sicking. File API. URL: https://www.w3.org/TR/FileAPI/

IDL Index

partial interface File {
    readonly attribute USVString webkitRelativePath;
};

partial interface HTMLInputElement {
    attribute boolean webkitdirectory;
    readonly attribute FrozenArray<FileSystemEntry> webkitEntries;
};

partial interface DataTransferItem {
    FileSystemEntry? webkitGetAsEntry();
};

callback interface ErrorCallback {
    void handleEvent(DOMException err);
};

interface FileSystemEntry {
    readonly attribute boolean isFile;
    readonly attribute boolean isDirectory;
    readonly attribute USVString name;
    readonly attribute USVString fullPath;
    readonly attribute FileSystem filesystem;

    void getParent(optional FileSystemEntryCallback successCallback,
                   optional ErrorCallback errorCallback);
};

interface FileSystemDirectoryEntry : FileSystemEntry {
    FileSystemDirectoryReader createReader();
    void getFile(optional USVString? path,
                 optional FileSystemFlags options,
                 optional FileSystemEntryCallback successCallback,
                 optional ErrorCallback errorCallback);
    void getDirectory(optional USVString? path,
                      optional FileSystemFlags options,
                      optional FileSystemEntryCallback successCallback,
                      optional ErrorCallback errorCallback);
};

dictionary FileSystemFlags {
    boolean create = false;
    boolean exclusive = false;
};

callback interface FileSystemEntryCallback {
    void handleEvent(FileSystemEntry entry);
};

interface FileSystemDirectoryReader {
    void readEntries(FileSystemEntriesCallback successCallback,
                     optional ErrorCallback errorCallback);
};
callback interface FileSystemEntriesCallback {
    void handleEvent(sequence<FileSystemEntry> entries);
};

interface FileSystemFileEntry : FileSystemEntry {
    void file(FileCallback successCallback,
              optional ErrorCallback errorCallback);
};
callback interface FileCallback {
    void handleEvent(File file);
};

interface FileSystem {
    readonly attribute USVString name;
    readonly attribute FileSystemDirectoryEntry root;
};

Issues Index

EDITORIAL: Should directory be defined as a special type of file so that minimal changes are necessary in [HTML]?
EDITORIAL: This section should be merged into [FileAPI] once it is complete.
EDITORIAL: This section should be merged into [HTML] once it is complete. Sections such as the steps to construct the form data set need to be extended to include the webkitRelativePath property.
INTEROP: In Chrome, webkitEntries is only populated as the result of a drag-and-drop operation, not when the element is clicked. Should we fix this so it is always populated?
INTEROP: In Chrome, if webkitdirectory is specified on a HTMLInputElement, webkitEntries is not populated; the files collection and webkitRelativePath properties must be used instead to reconstruct the directory structure. Should we fix this so it is always populated?
EDITORIAL: This section should be merged into [HTML] once it is complete.
WEB COMPAT: The legacy TypeMismatchError has been replaced in most specifications by TypeError, but the name differs. Is it compatible to switch here as well?