@salesforce/b2c-cli 1.11.0 → 1.12.1

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/File.d.ts

@@ -0,0 +1,343 @@
+import List = require('../util/List');
+
+/**
+ * Represents a file resource accessible from scripting. As with
+ * `java.io.File`, a `File` is essentially an
+ * "abstract pathname" which may or may not denote an actual file on the file
+ * system.  Methods `createNewFile`,
+ * `mkdir`, `mkdirs`, and `remove` are provided
+ * to actually manipulate physical files.
+ * 
+ * File access is limited to certain virtual directories.  These directories are
+ * a subset of those accessible through WebDAV.  As a result of this
+ * restriction, pathnames must be one of the following forms:
+ * 
+ * - `/TEMP(/...)`
+ * - `/IMPEX(/...)`
+ * - `/REALMDATA(/...)`
+ * - `/CATALOGS/[Catalog Name](/...)`
+ * - `/LIBRARIES/[Library Name](/...)`
+ * 
+ * Note, that these paths are analogous to the WebDAV URIs used to access the
+ * same directories.
+ * 
+ * The files are stored in a shared file system where multiple processes could
+ * access the same file. The programmer has to make sure no more than one process
+ * writes to a file at a given time.
+ * 
+ * This class provides other useful methods for listing the
+ * children of a directory and for working with zip files.
+ * 
+ * Note: when this class is used with sensitive data, be careful in persisting sensitive information.
+ * 
+ * For performance reasons no more than 100,000 files (regular files and directories) should be stored in a
+ * directory.
+ */
+declare class File {
+    /**
+     * Catalogs root directory.
+     */
+    static readonly CATALOGS: string;
+    /**
+     * Customer Payment Instrument root directory.
+     */
+    static readonly CUSTOMERPI: string;
+    /**
+     * Customer snapshots root directory.
+     */
+    static readonly CUSTOMER_SNAPSHOTS: string;
+    /**
+     * Reserved for future use.
+     */
+    static readonly DYNAMIC: string;
+    /**
+     * Import/export root directory.
+     */
+    static readonly IMPEX: string;
+    /**
+     * Libraries root directory.
+     */
+    static readonly LIBRARIES: string;
+    /**
+     * RealmData root directory.
+     * @deprecated Folder to be removed.
+     */
+    static readonly REALMDATA: string;
+    /**
+     * The UNIX style '/' path separator, which must be used for files paths.
+     */
+    static readonly SEPARATOR = "/";
+    /**
+     * Static content root directory.
+     */
+    static readonly STATIC: string;
+    /**
+     * Temp root directory.
+     */
+    static readonly TEMP: string;
+    /**
+     * Indicates that this file is a directory.
+     */
+    readonly directory: boolean;
+    /**
+     * Indicates if this file is a file.
+     */
+    readonly file: boolean;
+    /**
+     * Return the full file path denoted by this `File`.
+     * This value will be the same regardless of which constructor was
+     * used to create this `File`.
+     */
+    readonly fullPath: string;
+    /**
+     * Returns the name of the file or directory denoted by this object. This is
+     * just the last name in the pathname's name sequence. If the pathname's
+     * name sequence is empty, then the empty string is returned.
+     */
+    readonly name: string;
+    /**
+     * Returns the portion of the path relative to the root directory.
+     * @deprecated Use getFullPath to access the full path.
+     * This method does not return the correct path for files
+     * in the CATALOGS or LIBRARIES virtual directories.
+     */
+    readonly path: string;
+    /**
+     * Returns the root directory type, e.g. "IMPEX" represented by this
+     * `File`.
+     */
+    readonly rootDirectoryType: string;
+    /**
+     * Creates a `File` from the given absolute file path in the
+     * file namespace.  If the specified path is not a valid accessible path,
+     * an exception will be thrown.
+     * 
+     * The passed path should use the forward slash '/' as the path
+     * separator and begin with a leading slash.  However, if a leading slash
+     * is not provided, or the backslash character is used as the separator,
+     * these problems will be fixed.  The normalized value will then be returned
+     * by getFullPath.
+     */
+    constructor(absPath: string);
+    /**
+     * Creates a `File` given a root directory and a relative path.
+     */
+    constructor(rootDir: File, relPath: string);
+    /**
+     * Returns a `File` representing a directory for the specified
+     * root directory type. If the root directory
+     * type is CATALOGS or LIBRARIES, then an additional argument representing
+     * the specific catalog or library must be provided.  Otherwise, no
+     * additional arguments are needed.
+     */
+    static getRootDirectory(rootDir: string, ...args: string[]): File;
+    /**
+     * Copy a file. Directories cannot be copied. This method cannot be used from storefront requests.
+     * @throws IOException if there is an interruption during file copy.
+     * @throws FileAlreadyExistsException if the file to copy to already exists
+     * @throws UnsupportedOperationException if invoked from a storefront request
+     */
+    copyTo(file: File): File;
+    /**
+     * Create file.
+     * @throws Exception
+     */
+    createNewFile(): boolean;
+    /**
+     * Indicates if the file exists.
+     */
+    exists(): boolean;
+    /**
+     * Return the full file path denoted by this `File`.
+     * This value will be the same regardless of which constructor was
+     * used to create this `File`.
+     */
+    getFullPath(): string;
+    /**
+     * Returns the name of the file or directory denoted by this object. This is
+     * just the last name in the pathname's name sequence. If the pathname's
+     * name sequence is empty, then the empty string is returned.
+     */
+    getName(): string;
+    /**
+     * Returns the portion of the path relative to the root directory.
+     * @deprecated Use getFullPath to access the full path.
+     * This method does not return the correct path for files
+     * in the CATALOGS or LIBRARIES virtual directories.
+     */
+    getPath(): string;
+    /**
+     * Returns the root directory type, e.g. "IMPEX" represented by this
+     * `File`.
+     */
+    getRootDirectoryType(): string;
+    /**
+     * Assumes this instance is a gzip file. Unzipping it will
+     * explode the contents in the directory passed in (root).
+     * @throws Exception if the zip files contents can't be exploded.
+     */
+    gunzip(root: File): void;
+    /**
+     * GZip this instance into a new gzip file. If you're zipping a file, then a single entry, the instance,
+     * is included in the output gzip file. Note that a new File is created. GZipping directories is not supported.
+     * This file is never modified.
+     * @throws IOException if the zip file can't be created.
+     */
+    gzip(outputZipFile: File): void;
+    /**
+     * Indicates that this file is a directory.
+     */
+    isDirectory(): boolean;
+    /**
+     * Indicates if this file is a file.
+     */
+    isFile(): boolean;
+    /**
+     * Return the time, in milliseconds, that this file was last modified.
+     */
+    lastModified(): number;
+    /**
+     * Return the length of the file in bytes.
+     */
+    length(): number;
+    /**
+     * Returns an array of strings naming the files and directories in the
+     * directory denoted by this object.
+     * 
+     * If this object does not denote a directory, then this method returns
+     * `null`. Otherwise an array of strings is returned, one for
+     * each file or directory in the directory. Names denoting the directory
+     * itself and the directory's parent directory are not included in the
+     * result. Each string is a file name rather than a complete path.
+     * 
+     * There is no guarantee that the name strings in the resulting array will
+     * appear in any specific order; they are not, in particular, guaranteed to
+     * appear in alphabetical order.
+     */
+    list(): string[] | null;
+    /**
+     * Returns an array of `File` objects in the directory denoted
+     * by this `File`.
+     * 
+     * If this `File` does not denote a directory, then this method
+     * returns `null`. Otherwise an array of `File`
+     * objects is returned, one for each file or directory in the directory.
+     * Files denoting the directory itself and the directory's parent directory
+     * are not included in the result.
+     * 
+     * There is no guarantee that the files in the resulting array will appear
+     * in any specific order; they are not, in particular, guaranteed to appear
+     * in alphabetical order. Example usage:
+     * 
+     * `
+     * // Assume "foo" is an accessible directory.
+     * 
+     * var this_directory : dw.io.File = new File("foo");
+     * 
+     * // Find all files in directory foo, one level "down".
+     * 
+     * // listFiles() will not traverse subdirectories.
+     * 
+     * var folder : dw.util.List = this_directory.listFiles();
+     * 
+     * var first_element : dw.io.File = folder[0];
+     * 
+     * function modification_comparison(lhs : File, rhs : File)
+     * 
+     * {
+     * 
+     * return lhs.lastModified() < rhs.lastModified();
+     * 
+     * }
+     * 
+     * function lexigraphic_comparison(lhs: File, rhs : File)
+     * 
+     * {
+     * 
+     * return lhs.getName() < rhs.getName();
+     * 
+     * }
+     * 
+     * var time_ordered_folder : dw.util.ArrayList = folder.sort(modification_comparison);
+     * 
+     * var alphabetic_folder : dw.util.ArrayList = folder.sort(lexigraphic_comparison);
+     * 
+     * `
+     */
+    listFiles(): List<File> | null;
+    /**
+     * Returns an array of `File` objects denoting the files and
+     * directories in the directory denoted by this object that satisfy the
+     * specified filter. The behavior of this method is the same as that of the
+     * `listFiles` method, except that the files in the
+     * returned array must satisfy the filter. The filter is a Javascript
+     * function which accepts one argument, a `File`, and returns
+     * true or false depending on whether the file meets the filter conditions.
+     * If the given `filter` is `null` then all files
+     * are accepted. Otherwise, a file satisfies the filter if and only if the
+     * filter returns `true`. Example usage:
+     * 
+     * `
+     * // Assume "foo" is an accessible directory.
+     * 
+     * var this_directory : dw.io.File = new File("foo");
+     * 
+     * function longer_than_3(candidate : dw.io.File)
+     * 
+     * {
+     * 
+     * return candidate.getName().length > 3;
+     * 
+     * }
+     * 
+     * // Find all files in directory foo, one level "down",
+     * 
+     * // such that the filename is longer than 3 characters.
+     * 
+     * var folder_long_names : dw.util.List = this_directory.listFiles(longer_than_3);
+     * 
+     * `
+     */
+    listFiles(filter: Function): List<File> | null;
+    /**
+     * Returns an MD5 hash of the content of the file of this instance.
+     * @throws Exception if the file could not be read or is a directory.
+     */
+    md5(): string;
+    /**
+     * Creates a directory.
+     */
+    mkdir(): boolean;
+    /**
+     * Creates a directory, including, its parent directories, as needed.
+     */
+    mkdirs(): boolean;
+    /**
+     * Deletes the file or directory denoted by this object. If this File
+     * represents a directory, then the directory must be empty in order to be
+     * deleted.
+     */
+    remove(): boolean;
+    /**
+     * Rename file.
+     */
+    renameTo(file: File): boolean;
+    /**
+     * Assumes this instance is a zip file. Unzipping it will
+     * explode the contents in the directory passed in (root).
+     * @throws Exception if the zip files contents can't be exploded.
+     */
+    unzip(root: File): void;
+    /**
+     * Zip this instance into a new zip file. If you're zipping a directory,
+     * the directory itself and all its children files to any level (any number of subdirectories)
+     * are included in the zip file. The directory will be the only entry in the archive (single root).
+     * If you're zipping a file, then a single entry, the instance,
+     * is included in the output zip file. Note that a new File is created.
+     * This file is never modified.
+     * @throws IOException if the zip file can't be created.
+     */
+    zip(outputZipFile: File): void;
+}
+
+export = File;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/FileReader.d.ts

@@ -0,0 +1,26 @@
+import Reader = require('./Reader');
+import File = require('./File');
+
+/**
+ * File reader class.
+ */
+declare class FileReader extends Reader {
+    /**
+     * Constructs the reader.
+     * 
+     * To release system resources, close the reader by calling close.
+     */
+    constructor(file: File);
+    /**
+     * Constructs the reader.
+     * 
+     * To release system resources, close the reader by calling close.
+     */
+    constructor(file: File, encoding: string);
+    /**
+     * Closes the reader.
+     */
+    close(): void;
+}
+
+export = FileReader;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/FileWriter.d.ts

@@ -0,0 +1,62 @@
+import Writer = require('./Writer');
+import File = require('./File');
+
+/**
+ * Convenience class for writing character files.
+ * 
+ * Files are stored in a shared file system where multiple processes could
+ * access the same file. The client code is responsible for ensuring that no
+ * more than one process writes to a file at a given time.
+ * 
+ * Note: when this class is used with sensitive data, be careful in persisting sensitive information to disk.
+ */
+declare class FileWriter extends Writer {
+    /**
+     * Get the current line separator (e.g. '\n' or '\r\n'), if no value is set the system default '\n' will be used.
+     */
+    lineSeparator: string;
+    /**
+     * Constructs the writer for the specified file. Uses "UTF-8" as encoding.
+     * 
+     * To release system resources, close the writer by calling close.
+     */
+    constructor(file: File);
+    /**
+     * Constructs the writer for the specified file. Optional file append mode
+     * is supported. Uses "UTF-8" as encoding.
+     * 
+     * To release system resources, close the writer by calling close.
+     */
+    constructor(file: File, append: boolean);
+    /**
+     * Constructs the writer for the specified file with the specified encoding.
+     * 
+     * To release system resources, close the writer by calling close.
+     */
+    constructor(file: File, encoding: string);
+    /**
+     * Constructs the writer for the specified file with the specified encoding.
+     * Optional file append mode is supported.
+     * 
+     * To release system resources, close the writer by calling close.
+     */
+    constructor(file: File, encoding: string, append: boolean);
+    /**
+     * Closes the writer.
+     */
+    close(): void;
+    /**
+     * Get the current line separator (e.g. '\n' or '\r\n'), if no value is set the system default '\n' will be used.
+     */
+    getLineSeparator(): string;
+    /**
+     * Set the line separator (e.g. '\n' or '\r\n'), if no value is set the system default '\n' will be used.
+     */
+    setLineSeparator(lineSeparator: string): void;
+    /**
+     * Writes the specified line and appends the line separator.
+     */
+    writeLine(str: string): void;
+}
+
+export = FileWriter;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/InputStream.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The class represent a stream of bytes that can be read from the
+ * application. The InputStream itself doesn't provide any methods
+ * to read the data. Instead the InputStream can be chained with
+ * other classes like a XMLStreamReader to read data.
+ */
+declare class InputStream {
+    private constructor();
+    /**
+     * Closes the input stream.
+     */
+    close(): void;
+}
+
+export = InputStream;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/OutputStream.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The class represent a stream of bytes that can be written from the
+ * application. The OutputStream itself doesn't provide any methods
+ * to write the data. Instead the OutputStream can be chained with
+ * other classes like a XMLStreamWriter to write data.
+ * 
+ * Note: when this class is used with sensitive data, be careful in persisting sensitive information to disk.
+ */
+declare class OutputStream {
+    private constructor();
+    /**
+     * Closes the output stream.
+     */
+    close(): void;
+}
+
+export = OutputStream;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/PrintWriter.d.ts

@@ -0,0 +1,29 @@
+import Writer = require('./Writer');
+
+/**
+ * Template output stream writer.
+ * 
+ * Printwriter is available in the template scripting context and is used
+ * to write data into the template output stream. You cannot instantiate this class
+ * directly. Instead, the system assigns the object to variable named 'out' in the script context
+ * to be used by the template scripts.
+ * 
+ * Note: when this class is used with sensitive data, be careful in persisting sensitive information to disk.
+ */
+declare class PrintWriter extends Writer {
+    private constructor();
+    /**
+     * Prints the given string into the output stream.
+     */
+    print(str: string): void;
+    /**
+     * Print the given string followed by a line break into the output stream.
+     */
+    println(str: string): void;
+    /**
+     * Prints a line break into the output stream.
+     */
+    println(): void;
+}
+
+export = PrintWriter;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/RandomAccessFileReader.d.ts

@@ -0,0 +1,70 @@
+import File = require('./File');
+import Bytes = require('../util/Bytes');
+
+/**
+ * Instances of this class support reading from a random access file. A random
+ * access file behaves like a large array of bytes stored in the file system.
+ * There is a kind of cursor, or index into the implied array, called the file
+ * pointer. Read operations read bytes starting at the file pointer and advance
+ * the file pointer past the bytes read. The file pointer can be read by the
+ * getPosition method and set by the setPosition method.
+ */
+declare class RandomAccessFileReader {
+    /**
+     * The maximum number of bytes that a single call to readBytes can return == 10KB
+     */
+    static readonly MAX_READ_BYTES = 10240;
+    /**
+     * Returns the current offset in this file.
+     * @throws IOException if an I/O error occurs.
+     */
+    position: number;
+    /**
+     * Construct a reader for random read access to the provided file.
+     * 
+     * To release system resources, close the reader by calling close.
+     * @throws IOException If the given file object does not denote an existing regular file
+     */
+    constructor(file: File);
+    /**
+     * Closes this random access file reader and releases any system resources
+     * associated with the stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    close(): void;
+    /**
+     * Returns the current offset in this file.
+     * @throws IOException if an I/O error occurs.
+     */
+    getPosition(): number;
+    /**
+     * Returns the length of this file.
+     * @throws IOException if an I/O error occurs.
+     */
+    length(): number;
+    /**
+     * Reads a signed eight-bit value from the file starting from the current
+     * file pointer. Since the byte is interpreted as signed, the value returned
+     * will always be between -128 and +127.
+     * @throws IOException if an I/O error occurs or if this file has reached the end.
+     */
+    readByte(): number;
+    /**
+     * Reads up to n bytes from the file starting at the current file pointer.
+     * If there are fewer than n bytes remaining in the file, then as many bytes
+     * as possible are read. If no bytes remain in the file, then null is
+     * returned.
+     * @throws IOException if an I/O error occurs.
+     * @throws IllegalArgumentException if numBytes <  0 or numBytes > MAX_READ_BYTES.
+     */
+    readBytes(numBytes: number): Bytes | null;
+    /**
+     * Sets the file-pointer offset, measured from the beginning of this file,
+     * at which the next read occurs. The offset may be set beyond the end of
+     * the file.
+     * @throws IOException if position is less than 0 or if an I/O error occurs.
+     */
+    setPosition(position: number): void;
+}
+
+export = RandomAccessFileReader;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/io/Reader.d.ts

@@ -0,0 +1,105 @@
+import InputStream = require('./InputStream');
+import List = require('../util/List');
+
+/**
+ * The class supports reading characters from a stream.
+ */
+declare class Reader {
+    /**
+     * The method reads the whole input stream, parses it and returns a list of strings.
+     * 
+     * Using this method on large feeds is inherently unsafe and may lead to an out-of-memory condition. Instead use
+     * method readLine and process one line at a time.
+     * @deprecated Use readLines
+     */
+    readonly lines: List<string>;
+    /**
+     * The method reads the whole input stream as one string and returns it.
+     * 
+     * Using this method is unsafe if the length of the input stream is not known and may lead to an out-of-memory
+     * condition. Instead use method readN.
+     * @throws IOException if something went wrong while reading from the underlying stream
+     * @deprecated Use readString
+     */
+    readonly string: string;
+    /**
+     * Creates a reader from a string.
+     */
+    constructor(source: string);
+    /**
+     * Create a reader from a stream using UTF-8 character encoding.
+     */
+    constructor(stream: InputStream);
+    /**
+     * Create a reader from a stream using the specified character encoding.
+     */
+    constructor(stream: InputStream, encoding: string);
+    /**
+     * Closes the reader.
+     */
+    close(): void;
+    /**
+     * The method reads the whole input stream, parses it and returns a list of strings.
+     * 
+     * Using this method on large feeds is inherently unsafe and may lead to an out-of-memory condition. Instead use
+     * method readLine and process one line at a time.
+     * @deprecated Use readLines
+     */
+    getLines(): List<string>;
+    /**
+     * The method reads the whole input stream as one string and returns it.
+     * 
+     * Using this method is unsafe if the length of the input stream is not known and may lead to an out-of-memory
+     * condition. Instead use method readN.
+     * @throws IOException if something went wrong while reading from the underlying stream
+     * @deprecated Use readString
+     */
+    getString(): string;
+    /**
+     * Reads a single character from the stream. The method returns null if the end of the stream is reached.
+     */
+    read(): string | null;
+    /**
+     * Reads multiple characters from the stream as string. The actual number of characters that were read can be
+     * determined from the length of the returned string. If the end of the stream is reached and no more characters can
+     * be read, the method exits with an exception.
+     * @throws an exception if the stream is exhausted
+     * @deprecated use readN instead which does not throw an exception if the stream is exhausted
+     */
+    read(length: number): string;
+    /**
+     * Reads the next line.
+     */
+    readLine(): string | null;
+    /**
+     * The method reads the whole input stream, parses it and returns a list of strings.
+     * 
+     * Using this method on large feeds is inherently unsafe and may lead to an out-of-memory condition. Instead use
+     * method readLine and process one line at a time.
+     */
+    readLines(): List<string>;
+    /**
+     * Reads n characters from the stream as string. The actual number of characters that were read can be determined
+     * from the length of the returned string. If the end of the stream is reached and no more characters can be read,
+     * the method returns null.
+     */
+    readN(n: number): string | null;
+    /**
+     * The method reads the whole input stream as one string and returns it.
+     * 
+     * Using this method is unsafe if the length of the input stream is not known and may lead to an out-of-memory
+     * condition. Instead use method readN.
+     * @throws IOException if something went wrong while reading from the underlying stream
+     */
+    readString(): string;
+    /**
+     * Identifies if this stream is ready to be read.
+     */
+    ready(): boolean;
+    /**
+     * Skips the specified number of characters in the stream.
+     */
+    skip(n: number): void;
+}
+
+export = Reader;