Class FileSystem

Hierarchy

FileSystem

Implements

Constructors

constructor

new FileSystem(__namedParameters: ConstructorParams): FileSystem
Parameters
- __namedParameters: ConstructorParams
Returns FileSystem
- Defined in fs/filesystem.ts:102

Properties

_publishWhenOnline

_publishWhenOnline: [CID<unknown, number, number, Version>, Ucan][]

_publishing

_publishing: false | [CID<unknown, number, number, Version>, true]

account

account: AssociatedIdentity

dependencies

dependencies: Dependencies

eventEmitter

eventEmitter: EventEmitter<FileSystem>

`Readonly` localOnly

localOnly: boolean

proofs

proofs: {
[_: string]: Ucan;
}

Type declaration

[_: string]: Ucan

publishHooks

publishHooks: PublishHook[]

root

root: default

Methods

_beforeLeaving

_beforeLeaving(e: Event): string | void
Internal
Parameters
- e: Event
Returns string | void
- Defined in fs/filesystem.ts:846

_whenOnline

_whenOnline(): void
Internal
Returns void
- Defined in fs/filesystem.ts:836

acceptShare

acceptShare(__namedParameters: {
shareId: string;
sharedBy: string;
}): Promise<FileSystem>
Accept a share. Copies the links to the items into your 'Shared with me' directory. eg. private/Shared with me/Sharer/
Parameters
- __namedParameters: {
  shareId: string;
  sharedBy: string;
  }
  - shareId: string
  - sharedBy: string
Returns Promise<FileSystem>
Implementation of API.acceptShare
- Defined in fs/filesystem.ts:583

checkMutationPermissionAndAddProof

checkMutationPermissionAndAddProof(path: DistinctivePath<[Partition, ...string[]]>, isMutation: boolean): Promise<void>
Internal
Parameters
- path: DistinctivePath<[Partition, ...string[]]>
- isMutation: boolean
Returns Promise<void>
- Defined in fs/filesystem.ts:716

deactivate

deactivate(): void
Deactivate a file system.

Use this when a user signs out. The only function of this is to stop listing to online/offline events.

Returns void
- Defined in fs/filesystem.ts:206

exists

exists(path: Distinctive<[Partition, string, ...string[]]>): Promise<boolean>
Parameters
- path: Distinctive<[Partition, string, ...string[]]>
Returns Promise<boolean>
Implementation of API.exists
- Defined in fs/filesystem.ts:356

get

get(path: Distinctive<[Partition, ...string[]]>): Promise<null | PuttableUnixTree | File>
Parameters
- path: Distinctive<[Partition, ...string[]]>
Returns Promise<null | PuttableUnixTree | File>
Implementation of API.get
- Defined in fs/filesystem.ts:368

historyStep

historyStep(): Promise<void>
Ensures the current version of your file system is "committed" and stepped forward, so the current version will always be persisted as an "step" in the history of the file system.

This function is implicitly called every time your file system changes are synced, so in most cases calling this is handled for you.

Returns Promise<void>
Implementation of API.historyStep
- Defined in fs/filesystem.ts:566

loadShare

loadShare(__namedParameters: {
shareId: string;
sharedBy: string;
}): Promise<UnixTree>
Loads a share. Returns a "entry index", in other words, a private tree with symlinks (soft links) to the shared items.
Parameters
- __namedParameters: {
  shareId: string;
  sharedBy: string;
  }
  - shareId: string
  - sharedBy: string
Returns Promise<UnixTree>
Implementation of API.loadShare
- Defined in fs/filesystem.ts:597

ls

ls(path: Directory<[Partition, ...string[]]>): Promise<Links>
Parameters
- path: Directory<[Partition, ...string[]]>
Returns Promise<Links>
Implementation of API.ls
- Defined in fs/filesystem.ts:216

mkdir

mkdir(path: Directory<[Partition, string, ...string[]]>, options?: MutationOptions): Promise<FileSystem>
Parameters
- path: Directory<[Partition, string, ...string[]]>
- options: MutationOptions = {}
Returns Promise<FileSystem>
Implementation of API.mkdir
- Defined in fs/filesystem.ts:232

mv

mv(from: Distinctive<[Partition, string, ...string[]]>, to: Distinctive<[Partition, string, ...string[]]>): Promise<FileSystem>
Parameters
- from: Distinctive<[Partition, string, ...string[]]>
- to: Distinctive<[Partition, string, ...string[]]>
Returns Promise<FileSystem>
Implementation of API.mv
- Defined in fs/filesystem.ts:382

publish

publish(): Promise<CID<unknown, number, number, Version>>
Ensures the latest version of the file system is added to IPFS, updates your data root, and returns the root CID.

Returns Promise<CID<unknown, number, number, Version>>
Implementation of API.publish
- Defined in fs/filesystem.ts:541

read

read(path: path.File<[Partition, string, ...string[]]>): Promise<Uint8Array>
Parameters
- path: path.File<[Partition, string, ...string[]]>
Returns Promise<Uint8Array>
Implementation of API.read
- Defined in fs/filesystem.ts:338

resolveSymlink

resolveSymlink(link: SoftLink): Promise<null | File | Tree>
Resolve a symlink directly. The get and cat methods will automatically resolve symlinks, but sometimes when working with symlinks directly you might want to use this method instead.
Parameters
- link: SoftLink
Returns Promise<null | File | Tree>
Implementation of API.resolveSymlink
- Defined in fs/filesystem.ts:424

rm

rm(path: DistinctivePath<[Partition, ...string[]]>): Promise<FileSystem>
Parameters
- path: DistinctivePath<[Partition, ...string[]]>
Returns Promise<FileSystem>
Implementation of API.rm
- Defined in fs/filesystem.ts:432

runMutationOnNode

runMutationOnNode(path: DistinctivePath<[Partition, ...string[]]>, handlers: {
private(node: PrivateFile | default, relPath: Segments): Promise<void>;
public(root: UnixTree, relPath: Segments): Promise<void>;
}): Promise<void>
Internal
Parameters
- path: DistinctivePath<[Partition, ...string[]]>
- handlers: {
  private(node: PrivateFile | default, relPath: Segments): Promise<void>;
  public(root: UnixTree, relPath: Segments): Promise<void>;
  }
  - private:function
    - private(node: PrivateFile | default, relPath: Segments): Promise<void>
    - Parameters
      
      node: PrivateFile | default
      
      relPath: Segments
      
      Returns Promise<void>
      
      Defined in fs/filesystem.ts:735
  - public:function
    - public(root: UnixTree, relPath: Segments): Promise<void>
    - Parameters
      
      root: UnixTree
      
      relPath: Segments
      
      Returns Promise<void>
      
      Defined in fs/filesystem.ts:734
Returns Promise<void>
- Defined in fs/filesystem.ts:731

runOnChildTree

runOnChildTree(node: Tree, relPath: Segments, fn: ((tree: Tree) => Promise<Tree>)): Promise<Tree>
Internal
put should be called on the node returned from the function. Normally this is handled by runOnNode.
Parameters
- node: Tree
- relPath: Segments
- fn: ((tree: Tree) => Promise<Tree>)
  - - (tree: Tree): Promise<Tree>
    - Parameters
      
      tree: Tree
      
      Returns Promise<Tree>
Returns Promise<Tree>
- Defined in fs/filesystem.ts:819

runOnNode

runOnNode<A>(path: DistinctivePath<[Partition, ...string[]]>, handlers: {
private(node: File | Tree, relPath: Segments): Promise<A>;
public(root: UnixTree, relPath: Segments): Promise<A>;
}): Promise<A>
Internal
Type Parameters
- A
Parameters
- path: DistinctivePath<[Partition, ...string[]]>
- handlers: {
  private(node: File | Tree, relPath: Segments): Promise<A>;
  public(root: UnixTree, relPath: Segments): Promise<A>;
  }
  - private:function
    - private(node: File | Tree, relPath: Segments): Promise<A>
    - Parameters
      
      node: File | Tree
      
      relPath: Segments
      
      Returns Promise<A>
      
      Defined in fs/filesystem.ts:785
  - public:function
    - public(root: UnixTree, relPath: Segments): Promise<A>
    - Parameters
      
      root: UnixTree
      
      relPath: Segments
      
      Returns Promise<A>
      
      Defined in fs/filesystem.ts:784
Returns Promise<A>
- Defined in fs/filesystem.ts:781

sharePrivate

sharePrivate(paths: Distinctive<[Private, string, ...string[]]>[], __namedParameters: {
shareWith: string | string[];
sharedBy?: SharedBy;
}): Promise<ShareDetails>
Share a private file with a user.
Parameters
- paths: Distinctive<[Private, string, ...string[]]>[]
- __namedParameters: {
  shareWith: string | string[];
  sharedBy?: SharedBy;
  }
  - shareWith: string | string[]
  - Optional sharedBy?: SharedBy
Returns Promise<ShareDetails>
Implementation of API.sharePrivate
- Defined in fs/filesystem.ts:665

symlink

symlink(args: {
    at: Directory<[Partition, ...string[]]>;
    name: string;
    referringTo: {
        path: Distinctive<[Partition, ...string[]]>;
        username?: string;
    };
}): Promise<FileSystem>
Make a symbolic link at a path.
Parameters
- args: {
      at: Directory<[Partition, ...string[]]>;
      name: string;
      referringTo: {
          path: Distinctive<[Partition, ...string[]]>;
          username?: string;
      };
  }
  - at: Directory<[Partition, ...string[]]>
  - name: string
  - referringTo: {
    path: Distinctive<[Partition, ...string[]]>;
    username?: string;
    }
    - path: Distinctive<[Partition, ...string[]]>
    - Optional username?: string
Returns Promise<FileSystem>
Implementation of API.symlink
- Defined in fs/filesystem.ts:452

write

write(path: Distinctive<[Partition, ...string[]]>, content: Uint8Array | SoftLink | Record<string, SoftLink> | SoftLink[], options?: MutationOptions): Promise<FileSystem>
Parameters
- path: Distinctive<[Partition, ...string[]]>
- content: Uint8Array | SoftLink | Record<string, SoftLink> | SoftLink[]
- options: MutationOptions = {}
Returns Promise<FileSystem>
Implementation of API.write
- Defined in fs/filesystem.ts:257

`Static` empty

empty(opts: NewFileSystemOptions): Promise<FileSystem>
Creates a file system with an empty public tree & an empty private tree at the root.
Parameters
- opts: NewFileSystemOptions
Returns Promise<FileSystem>
- Defined in fs/filesystem.ts:159

`Static` fromCID

fromCID(cid: CID<unknown, number, number, Version>, opts: FileSystemOptions): Promise<FileSystem>
Loads an existing file system from a CID.
Parameters
- cid: CID<unknown, number, number, Version>
- opts: FileSystemOptions
Returns Promise<FileSystem>
- Defined in fs/filesystem.ts:183

Class FileSystem

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

__namedParameters: ConstructorParams

Returns FileSystem

Properties

_publishWhenOnline

_publishing

account

dependencies

eventEmitter

Readonly localOnly

proofs

Type declaration

[_: string]: Ucan

publishHooks

root

Methods

_beforeLeaving

Parameters

e: Event

Returns string | void

_whenOnline

Returns void

acceptShare

Parameters

__namedParameters: { shareId: string; sharedBy: string; }

shareId: string

sharedBy: string

Returns Promise<FileSystem>

checkMutationPermissionAndAddProof

Parameters

path: DistinctivePath<[Partition, ...string[]]>

isMutation: boolean

Returns Promise<void>

deactivate

Returns void

exists

Parameters

path: Distinctive<[Partition, string, ...string[]]>

Returns Promise<boolean>

get

Parameters

path: Distinctive<[Partition, ...string[]]>

Returns Promise<null | PuttableUnixTree | File>

historyStep

Returns Promise<void>

loadShare

Parameters

__namedParameters: { shareId: string; sharedBy: string; }

shareId: string

sharedBy: string

Returns Promise<UnixTree>

ls

Parameters

path: Directory<[Partition, ...string[]]>

Returns Promise<Links>

mkdir

Parameters

path: Directory<[Partition, string, ...string[]]>

options: MutationOptions = {}

Returns Promise<FileSystem>

mv

Parameters

from: Distinctive<[Partition, string, ...string[]]>

to: Distinctive<[Partition, string, ...string[]]>

Returns Promise<FileSystem>

publish

Returns Promise<CID<unknown, number, number, Version>>

read

Parameters

path: path.File<[Partition, string, ...string[]]>

Returns Promise<Uint8Array>

`Readonly` localOnly

__namedParameters: {
shareId: string;
sharedBy: string;
}

__namedParameters: {
shareId: string;
sharedBy: string;
}

handlers: {
private(node: PrivateFile | default, relPath: Segments): Promise<void>;
public(root: UnixTree, relPath: Segments): Promise<void>;
}

handlers: {
private(node: File | Tree, relPath: Segments): Promise<A>;
public(root: UnixTree, relPath: Segments): Promise<A>;
}

__namedParameters: {
shareWith: string | string[];
sharedBy?: SharedBy;
}

`Optional` sharedBy?: SharedBy

args: {
at: Directory<[Partition, ...string[]]>;
name: string;
referringTo: {
path: Distinctive<[Partition, ...string[]]>;
username?: string;
};
}

referringTo: {
path: Distinctive<[Partition, ...string[]]>;
username?: string;
}

`Optional` username?: string