@wp-playground/blueprints 0.1.40 → 0.1.43

package/lib/blueprint.d.ts

@@ -0,0 +1,27 @@
+import { SupportedPHPVersion } from '@php-wasm/universal';
+import { StepDefinition } from './steps';
+export interface Blueprint {
+    /**
+     * The URL to navigate to after the blueprint has been run.
+     */
+    landingPage?: string;
+    /**
+     * The preferred PHP and WordPress versions to use.
+     */
+    preferredVersions?: {
+        /**
+         * The preferred PHP version to use.
+         * If not specified, the latest supported version will be used
+         */
+        php: SupportedPHPVersion | 'latest';
+        /**
+         * The preferred WordPress version to use.
+         * If not specified, the latest supported version will be used
+         */
+        wp: string | 'latest';
+    };
+    /**
+     * The steps to run.
+     */
+    steps?: Array<StepDefinition | string | undefined | false | null>;
+}

package/lib/compile.d.ts

@@ -0,0 +1,37 @@
+import { ProgressTracker } from '@php-wasm/progress';
+import { Semaphore } from '@php-wasm/util';
+import { SupportedPHPVersion, UniversalPHP } from '@php-wasm/universal';
+import { StepDefinition } from './steps';
+import { Blueprint } from './blueprint';
+export type CompiledStep = (php: UniversalPHP) => Promise<void> | void;
+declare const supportedWordPressVersions: readonly ["6.2", "6.1", "6.0", "5.9"];
+type supportedWordPressVersion = (typeof supportedWordPressVersions)[number];
+export interface CompiledBlueprint {
+    /** The requested versions of PHP and WordPress for the blueprint */
+    versions: {
+        php: SupportedPHPVersion;
+        wp: supportedWordPressVersion;
+    };
+    /** The compiled steps for the blueprint */
+    run: (playground: UniversalPHP) => Promise<void>;
+}
+export type OnStepCompleted = (output: any, step: StepDefinition) => any;
+export interface CompileBlueprintOptions {
+    /** Optional progress tracker to monitor progress */
+    progress?: ProgressTracker;
+    /** Optional semaphore to control access to a shared resource */
+    semaphore?: Semaphore;
+    /** Optional callback with step output */
+    onStepCompleted?: OnStepCompleted;
+}
+/**
+ * Compiles Blueprint into a form that can be executed.
+ *
+ * @param playground The PlaygroundClient to use for the compilation
+ * @param blueprint The bBueprint to compile
+ * @param options Additional options for the compilation
+ * @returns The compiled blueprint
+ */
+export declare function compileBlueprint(blueprint: Blueprint, { progress, semaphore, onStepCompleted, }?: CompileBlueprintOptions): CompiledBlueprint;
+export declare function runBlueprintSteps(compiledBlueprint: CompiledBlueprint, playground: UniversalPHP): Promise<void>;
+export {};

package/lib/resources.d.ts

@@ -0,0 +1,211 @@
+import { ProgressTracker } from '@php-wasm/progress';
+import { UniversalPHP } from '@php-wasm/universal';
+import { Semaphore } from '@php-wasm/util';
+export declare const ResourceTypes: readonly ["vfs", "literal", "wordpress.org/themes", "wordpress.org/plugins", "url"];
+export type VFSReference = {
+    /** Identifies the file resource as Virtual File System (VFS) */
+    resource: 'vfs';
+    /** The path to the file in the VFS */
+    path: string;
+};
+export type LiteralReference = {
+    /** Identifies the file resource as a literal file */
+    resource: 'literal';
+    /** The name of the file */
+    name: string;
+    /** The contents of the file */
+    contents: string | Uint8Array;
+};
+export type CoreThemeReference = {
+    /** Identifies the file resource as a WordPress Core theme */
+    resource: 'wordpress.org/themes';
+    /** The slug of the WordPress Core theme */
+    slug: string;
+};
+export type CorePluginReference = {
+    /** Identifies the file resource as a WordPress Core plugin */
+    resource: 'wordpress.org/plugins';
+    /** The slug of the WordPress Core plugin */
+    slug: string;
+};
+export type UrlReference = {
+    /** Identifies the file resource as a URL */
+    resource: 'url';
+    /** The URL of the file */
+    url: string;
+    /** Optional caption for displaying a progress message */
+    caption?: string;
+};
+export type FileReference = VFSReference | LiteralReference | CoreThemeReference | CorePluginReference | UrlReference;
+export declare function isFileReference(ref: any): ref is FileReference;
+export interface ResourceOptions {
+    /** Optional semaphore to limit concurrent downloads */
+    semaphore?: Semaphore;
+    progress?: ProgressTracker;
+}
+export declare abstract class Resource {
+    /** Optional progress tracker to monitor progress */
+    abstract progress?: ProgressTracker;
+    /** A Promise that resolves to the file contents */
+    protected promise?: Promise<File>;
+    protected playground?: UniversalPHP;
+    /**
+     * Creates a new Resource based on the given file reference
+     *
+     * @param ref The file reference to create the Resource for
+     * @param options Additional options for the Resource
+     * @returns A new Resource instance
+     */
+    static create(ref: FileReference, { semaphore, progress }: ResourceOptions): Resource;
+    setPlayground(playground: UniversalPHP): void;
+    /**
+     * Resolves the file contents
+     * @returns The resolved file.
+     */
+    abstract resolve(): Promise<File>;
+    /** The name of the referenced file */
+    abstract get name(): string;
+    /** Whether this Resource is loaded asynchronously */
+    get isAsync(): boolean;
+}
+/**
+ * A `Resource` that represents a file in the VFS (virtual file system) of the playground.
+ */
+export declare class VFSResource extends Resource {
+    private resource;
+    progress?: ProgressTracker | undefined;
+    /**
+     * Creates a new instance of `VFSResource`.
+     * @param playground The playground client.
+     * @param resource The VFS reference.
+     * @param progress The progress tracker.
+     */
+    constructor(resource: VFSReference, progress?: ProgressTracker | undefined);
+    /** @inheritDoc */
+    resolve(): Promise<File>;
+    /** @inheritDoc */
+    get name(): string;
+}
+/**
+ * A `Resource` that represents a literal file.
+ */
+export declare class LiteralResource extends Resource {
+    private resource;
+    progress?: ProgressTracker | undefined;
+    /**
+     * Creates a new instance of `LiteralResource`.
+     * @param resource The literal reference.
+     * @param progress The progress tracker.
+     */
+    constructor(resource: LiteralReference, progress?: ProgressTracker | undefined);
+    /** @inheritDoc */
+    resolve(): Promise<File>;
+    /** @inheritDoc */
+    get name(): string;
+}
+/**
+ * A base class for `Resource`s that require fetching data from a remote URL.
+ */
+export declare abstract class FetchResource extends Resource {
+    progress?: ProgressTracker | undefined;
+    /**
+     * Creates a new instance of `FetchResource`.
+     * @param progress The progress tracker.
+     */
+    constructor(progress?: ProgressTracker | undefined);
+    /** @inheritDoc */
+    resolve(): Promise<File>;
+    /**
+     * Gets the URL to fetch the data from.
+     * @returns The URL.
+     */
+    protected abstract getURL(): string;
+    /**
+     * Gets the caption for the progress tracker.
+     * @returns The caption.
+     */
+    protected get caption(): string;
+    /** @inheritDoc */
+    get name(): string;
+    /** @inheritDoc */
+    get isAsync(): boolean;
+}
+/**
+ * A `Resource` that represents a file available from a URL.
+ */
+export declare class UrlResource extends FetchResource {
+    private resource;
+    /**
+     * Creates a new instance of `UrlResource`.
+     * @param resource The URL reference.
+     * @param progress The progress tracker.
+     */
+    constructor(resource: UrlReference, progress?: ProgressTracker);
+    /** @inheritDoc */
+    getURL(): string;
+    /** @inheritDoc */
+    protected get caption(): string;
+}
+export declare function setPluginProxyURL(url: string): void;
+/**
+ * A `Resource` that represents a WordPress core theme.
+ */
+export declare class CoreThemeResource extends FetchResource {
+    private resource;
+    constructor(resource: CoreThemeReference, progress?: ProgressTracker);
+    get name(): string;
+    getURL(): string;
+}
+/**
+ * A resource that fetches a WordPress plugin from wordpress.org.
+ */
+export declare class CorePluginResource extends FetchResource {
+    private resource;
+    constructor(resource: CorePluginReference, progress?: ProgressTracker);
+    /** @inheritDoc */
+    get name(): string;
+    /** @inheritDoc */
+    getURL(): string;
+}
+/**
+ * Transforms a plugin slug into a directory zip name.
+ * If the input already ends with ".zip", returns it unchanged.
+ * Otherwise, appends ".latest-stable.zip".
+ */
+export declare function toDirectoryZipName(rawInput: string): string;
+/**
+ * A decorator for a resource that adds functionality such as progress tracking and caching.
+ */
+export declare class DecoratedResource<T extends Resource> extends Resource {
+    private resource;
+    constructor(resource: T);
+    /** @inheritDoc */
+    resolve(): Promise<File>;
+    /** @inheritDoc */
+    setPlayground(playground: UniversalPHP): Promise<void>;
+    /** @inheritDoc */
+    get progress(): ProgressTracker | undefined;
+    /** @inheritDoc */
+    set progress(value: ProgressTracker | undefined);
+    /** @inheritDoc */
+    get name(): string;
+    /** @inheritDoc */
+    get isAsync(): boolean;
+}
+/**
+ * A decorator for a resource that adds caching functionality.
+ */
+export declare class CachedResource<T extends Resource> extends DecoratedResource<T> {
+    protected promise?: Promise<File>;
+    /** @inheritDoc */
+    resolve(): Promise<File>;
+}
+/**
+ * A decorator for a resource that adds concurrency control functionality through a semaphore.
+ */
+export declare class SemaphoreResource<T extends Resource> extends DecoratedResource<T> {
+    private readonly semaphore;
+    constructor(resource: T, semaphore: Semaphore);
+    /** @inheritDoc */
+    resolve(): Promise<File>;
+}

package/lib/steps/activate-plugin.d.ts

@@ -0,0 +1,12 @@
+import { StepHandler } from '.';
+export interface ActivatePluginStep {
+    step: 'activatePlugin';
+    plugin: string;
+}
+/**
+ * Activates a WordPress plugin in the Playground.
+ *
+ * @param playground The playground client.
+ * @param plugin The plugin slug.
+ */
+export declare const activatePlugin: StepHandler<ActivatePluginStep>;

package/lib/steps/apply-wordpress-patches/index.d.ts

@@ -0,0 +1,12 @@
+import { StepHandler } from '..';
+export interface ApplyWordPressPatchesStep {
+    step: 'applyWordPressPatches';
+    siteUrl: string;
+    wordpressPath?: string;
+    patchSqlitePlugin?: boolean;
+    addPhpInfo?: boolean;
+    patchSiteUrl?: boolean;
+    disableSiteHealth?: boolean;
+    disableWpNewBlogNotification?: boolean;
+}
+export declare const applyWordPressPatches: StepHandler<ApplyWordPressPatchesStep>;

package/lib/steps/client-methods.d.ts

@@ -0,0 +1,56 @@
+import { PHPRunOptions, PHPRequest } from '@php-wasm/universal';
+import { StepHandler } from '.';
+export interface RunPHPStep {
+    step: 'runPHP';
+    code: string;
+}
+export declare const runPHP: StepHandler<RunPHPStep>;
+export interface RunPHPWithOptionsStep {
+    step: 'runPHPWithOptions';
+    options: PHPRunOptions;
+}
+export declare const runPHPWithOptions: StepHandler<RunPHPWithOptionsStep>;
+export interface SetPhpIniEntryStep {
+    step: 'setPhpIniEntry';
+    key: string;
+    value: string;
+}
+export declare const setPhpIniEntry: StepHandler<SetPhpIniEntryStep>;
+export interface RequestStep {
+    step: 'request';
+    request: PHPRequest;
+}
+export declare const request: StepHandler<RequestStep>;
+export interface CpStep {
+    step: 'cp';
+    fromPath: string;
+    toPath: string;
+}
+export declare const cp: StepHandler<CpStep>;
+export interface MvStep {
+    step: 'mv';
+    fromPath: string;
+    toPath: string;
+}
+export declare const mv: StepHandler<MvStep>;
+export interface MkdirStep {
+    step: 'mkdir';
+    path: string;
+}
+export declare const mkdir: StepHandler<MkdirStep>;
+export interface RmStep {
+    step: 'rm';
+    path: string;
+}
+export declare const rm: StepHandler<RmStep>;
+export interface RmdirStep {
+    step: 'rmdir';
+    path: string;
+}
+export declare const rmdir: StepHandler<RmdirStep>;
+export interface WriteFileStep<ResourceType> {
+    step: 'writeFile';
+    path: string;
+    data: ResourceType | string | Uint8Array;
+}
+export declare const writeFile: StepHandler<WriteFileStep<File>>;

package/lib/steps/common.d.ts

@@ -0,0 +1,9 @@
+import type { PHPResponse, UniversalPHP } from '@php-wasm/universal';
+export declare function asDOM(response: PHPResponse): Document;
+export declare function zipNameToHumanName(zipName: string): string;
+type PatchFileCallback = (contents: string) => string | Uint8Array;
+export declare function updateFile(php: UniversalPHP, path: string, callback: PatchFileCallback): Promise<void>;
+export declare function fileToUint8Array(file: File): Promise<Uint8Array>;
+export declare const VFS_CONFIG_FILE_BASENAME = "/vfs-blueprints";
+export declare const VFS_CONFIG_FILE_PATH = "/vfs-blueprints/wp-config-consts.php";
+export {};

package/lib/steps/define-site-url.d.ts

@@ -0,0 +1,12 @@
+import { StepHandler } from '.';
+export interface DefineSiteUrlStep {
+    step: 'defineSiteUrl';
+    siteUrl: string;
+}
+/**
+ * Sets site URL of the WordPress installation.
+ *
+ * @param playground The playground client.
+ * @param siteUrl
+ */
+export declare const defineSiteUrl: StepHandler<DefineSiteUrlStep>;

package/lib/steps/define-virtual-wp-config-consts.d.ts

@@ -0,0 +1,19 @@
+import { StepHandler } from '.';
+/**
+ * The step object for defining constants in the VFS_CONFIG_FILE_PATH php file and loaded using the auto_prepend_file php.ini directive.
+ */
+export interface DefineVirtualWpConfigConstsStep {
+    step: 'defineVirtualWpConfigConsts';
+    /** The constants to define */
+    consts: Record<string, unknown>;
+}
+/**
+ * Function to define constants in the virtual VFS_CONFIG_FILE_PATH php file of a WordPress installation.
+ * The file should be dynamically loaded using the auto_prepend_file php.ini directive after this step.
+ *
+ * @param playground The playground client.
+ * @param wpConfigConst An object containing the constants to be defined and the optional virtual file system configuration file path.
+ * @returns Returns the virtual file system configuration file path.
+ * @see {@link https://www.php.net/manual/en/ini.core.php#ini.auto-prepend-file}
+ */
+export declare const defineVirtualWpConfigConsts: StepHandler<DefineVirtualWpConfigConstsStep>;

package/lib/steps/define-wp-config-consts.d.ts

@@ -0,0 +1,16 @@
+import { StepHandler } from '.';
+/**
+ * The step object for defining constants in the wp-config.php file of a WordPress installation.
+ */
+export interface DefineWpConfigConstsStep {
+    step: 'defineWpConfigConsts';
+    /** The constants to define */
+    consts: Record<string, unknown>;
+}
+/**
+ * Sets site URL of the WordPress installation.
+ *
+ * @param playground The playground client.
+ * @param wpConfigConst
+ */
+export declare const defineWpConfigConsts: StepHandler<DefineWpConfigConstsStep>;

package/{src/lib/steps/handlers.ts → lib/steps/handlers.d.ts}

@@ -1,17 +1,6 @@
 export { activatePlugin } from './activate-plugin';
 export { applyWordPressPatches } from './apply-wordpress-patches';
-export {
-	rm,
-	cp,
-	mkdir,
-	rmdir,
-	mv,
-	setPhpIniEntry,
-	runPHP,
-	runPHPWithOptions,
-	request,
-	writeFile,
-} from './client-methods';
+export { rm, cp, mkdir, rmdir, mv, setPhpIniEntry, runPHP, runPHPWithOptions, request, writeFile, } from './client-methods';
 export { defineSiteUrl } from './define-site-url';
 export { importFile, unzip, replaceSite, zipEntireSite } from './import-export';
 export { installPlugin } from './install-plugin';
@@ -20,3 +9,4 @@ export { login } from './login';
 export { runWpInstallationWizard } from './run-wp-installation-wizard';
 export { setSiteOptions, updateUserMeta } from './site-data';
 export { defineWpConfigConsts } from './define-wp-config-consts';
+export { defineVirtualWpConfigConsts } from './define-virtual-wp-config-consts';

package/lib/steps/import-export.d.ts

@@ -0,0 +1,67 @@
+import { UniversalPHP } from '@php-wasm/universal';
+import { StepHandler } from '.';
+/**
+ * Full site export support:
+ */
+/**
+ * Export the current site as a zip file.
+ *
+ * @param playground Playground client.
+ */
+export declare function zipEntireSite(playground: UniversalPHP): Promise<File>;
+export interface ReplaceSiteStep<ResourceType> {
+    step: 'replaceSite';
+    fullSiteZip: ResourceType;
+}
+/**
+ * Replace the current site with the contents of a full site zip file.
+ *
+ * @param playground Playground client.
+ * @param fullSiteZip Zipped WordPress site.
+ */
+export declare const replaceSite: StepHandler<ReplaceSiteStep<File>>;
+export interface UnzipStep {
+    step: 'unzip';
+    zipPath: string;
+    extractToPath: string;
+}
+/**
+ * Unzip a zip file.
+ *
+ * @param playground Playground client.
+ * @param zipPath The zip file to unzip.
+ * @param extractTo The directory to extract the zip file to.
+ */
+export declare const unzip: StepHandler<UnzipStep>;
+/**
+ * WXR and WXZ files support:
+ */
+/**
+ * Exports the WordPress database as a WXR file using
+ * the core WordPress export tool.
+ *
+ * @param playground Playground client
+ * @returns WXR file
+ */
+export declare function exportWXR(playground: UniversalPHP): Promise<File>;
+/**
+ * Exports the WordPress database as a WXZ file using
+ * the export-wxz plugin from https://github.com/akirk/export-wxz.
+ *
+ * @param playground Playground client
+ * @returns WXZ file
+ */
+export declare function exportWXZ(playground: UniversalPHP): Promise<File>;
+export interface ImportFileStep<ResourceType> {
+    step: 'importFile';
+    file: ResourceType;
+}
+/**
+ * Uploads a file to the WordPress importer and returns the response.
+ * Supports both WXR and WXZ files.
+ *
+ * @see https://github.com/WordPress/wordpress-importer/compare/master...akirk:wordpress-importer:import-wxz.patch
+ * @param playground Playground client.
+ * @param file The file to import.
+ */
+export declare const importFile: StepHandler<ImportFileStep<File>>;

package/lib/steps/index.d.ts

@@ -0,0 +1,28 @@
+import { ProgressTracker } from '@php-wasm/progress';
+import { UniversalPHP } from '@php-wasm/universal';
+import { FileReference } from '../resources';
+import { ActivatePluginStep } from './activate-plugin';
+import { ApplyWordPressPatchesStep } from './apply-wordpress-patches';
+import { DefineSiteUrlStep } from './define-site-url';
+import { ImportFileStep, ReplaceSiteStep, UnzipStep } from './import-export';
+import { InstallPluginStep, InstallPluginOptions } from './install-plugin';
+import { InstallThemeStep, InstallThemeOptions } from './install-theme';
+import { LoginStep } from './login';
+import { RunWpInstallationWizardStep, WordPressInstallationOptions } from './run-wp-installation-wizard';
+import { SetSiteOptionsStep, UpdateUserMetaStep } from './site-data';
+import { RmStep, CpStep, MkdirStep, RmdirStep, MvStep, SetPhpIniEntryStep, RunPHPStep, RunPHPWithOptionsStep, RequestStep, WriteFileStep } from './client-methods';
+import { DefineWpConfigConstsStep } from './define-wp-config-consts';
+import { DefineVirtualWpConfigConstsStep } from './define-virtual-wp-config-consts';
+export type Step = GenericStep<FileReference>;
+export type StepDefinition = Step & {
+    progress?: {
+        weight?: number;
+        caption?: string;
+    };
+};
+export type GenericStep<Resource> = ActivatePluginStep | ApplyWordPressPatchesStep | CpStep | DefineWpConfigConstsStep | DefineVirtualWpConfigConstsStep | DefineSiteUrlStep | ImportFileStep<Resource> | InstallPluginStep<Resource> | InstallThemeStep<Resource> | LoginStep | MkdirStep | MvStep | RequestStep | ReplaceSiteStep<Resource> | RmStep | RmdirStep | RunPHPStep | RunPHPWithOptionsStep | RunWpInstallationWizardStep | SetPhpIniEntryStep | SetSiteOptionsStep | UnzipStep | UpdateUserMetaStep | WriteFileStep<Resource>;
+export type { ActivatePluginStep, ApplyWordPressPatchesStep, CpStep, DefineWpConfigConstsStep, DefineSiteUrlStep, ImportFileStep, InstallPluginStep, InstallPluginOptions, InstallThemeStep, InstallThemeOptions, LoginStep, MkdirStep, MvStep, RequestStep, ReplaceSiteStep, RmStep, RmdirStep, RunPHPStep, RunPHPWithOptionsStep, RunWpInstallationWizardStep, WordPressInstallationOptions, SetPhpIniEntryStep, SetSiteOptionsStep, UnzipStep, UpdateUserMetaStep, WriteFileStep, };
+export type StepHandler<S extends GenericStep<File>> = (php: UniversalPHP, args: Omit<S, 'step'>, progressArgs?: {
+    tracker: ProgressTracker;
+    initialCaption?: string;
+}) => any;

package/lib/steps/install-plugin.d.ts

@@ -0,0 +1,46 @@
+import { StepHandler } from '.';
+/**
+ * The step to install a WordPress plugin in the Playground.
+ *
+ * @example
+ *
+ * <code>
+ * {
+ * 	    "step": "installPlugin",
+ * 		"pluginZipFile": "http://example.com/plugin.zip",
+ * 		"options": {
+ * 			"activate": true
+ * 		}
+ * }
+ * </code>
+ */
+export interface InstallPluginStep<ResourceType> {
+    /**
+     * The step identifier.
+     */
+    step: 'installPlugin';
+    /**
+     * The plugin zip file to install.
+     */
+    pluginZipFile: ResourceType;
+    /**
+     * Optional installation options.
+     */
+    options?: InstallPluginOptions;
+}
+export interface InstallPluginOptions {
+    /**
+     * Whether to activate the plugin after installing it.
+     */
+    activate?: boolean;
+}
+/**
+ * Installs a WordPress plugin in the Playground.
+ * Technically, it uses the same plugin upload form as a WordPress user
+ * would, and then activates the plugin if needed.
+ *
+ * @param playground The playground client.
+ * @param pluginZipFile The plugin zip file.
+ * @param options Optional. Set `activate` to false if you don't want to activate the plugin.
+ */
+export declare const installPlugin: StepHandler<InstallPluginStep<File>>;

package/lib/steps/install-theme.d.ts

@@ -0,0 +1,22 @@
+import { StepHandler } from '.';
+export interface InstallThemeStep<ResourceType> {
+    step: 'installTheme';
+    themeZipFile: ResourceType;
+    options?: InstallThemeOptions;
+}
+export interface InstallThemeOptions {
+    /**
+     * Whether to activate the theme after installing it.
+     */
+    activate?: boolean;
+}
+/**
+ * Installs a WordPress theme in the Playground.
+ * Technically, it uses the same theme upload form as a WordPress user
+ * would, and then activates the theme if needed.
+ *
+ * @param playground The playground client.
+ * @param themeZipFile The theme zip file.
+ * @param options Optional. Set `activate` to false if you don't want to activate the theme.
+ */
+export declare const installTheme: StepHandler<InstallThemeStep<File>>;

package/lib/steps/login.d.ts

@@ -0,0 +1,16 @@
+import { StepHandler } from '.';
+export type LoginStep = {
+    step: 'login';
+    username?: string;
+    password?: string;
+};
+/**
+ * Logs in to the Playground.
+ * Under the hood, this function submits the wp-login.php form
+ * just like a user would.
+ *
+ * @param playground The playground client.
+ * @param user The user to log in as. Defaults to 'admin'.
+ * @param password The password to log in with. Defaults to 'password'.
+ */
+export declare const login: StepHandler<LoginStep>;

package/lib/steps/migration.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "<?php\n\nfunction zipDir($dir, $output, $additionalFiles = array())\n{\n    $zip = new ZipArchive;\n    $res = $zip->open($output, ZipArchive::CREATE);\n    if ($res === TRUE) {\n        foreach ($additionalFiles as $file) {\n            $zip->addFile($file);\n        }\n        $directories = array(\n            rtrim($dir, '/') . '/'\n        );\n        while (sizeof($directories)) {\n            $dir = array_pop($directories);\n\n            if ($handle = opendir($dir)) {\n                while (false !== ($entry = readdir($handle))) {\n                    if ($entry == '.' || $entry == '..') {\n                        continue;\n                    }\n\n                    $entry = $dir . $entry;\n\n                    if (is_dir($entry)) {\n                        $directory_path = $entry . '/';\n                        array_push($directories, $directory_path);\n                    } else if (is_file($entry)) {\n                        $zip->addFile($entry);\n                    }\n                }\n                closedir($handle);\n            }\n        }\n        $zip->close();\n        chmod($output, 0777);\n    }\n}\n\nfunction unzip($zipPath, $extractTo, $overwrite = true)\n{\n    if(!is_dir($extractTo)) {\n        mkdir($extractTo, 0777, true);\n    }\n    $zip = new ZipArchive;\n    $res = $zip->open($zipPath);\n    if ($res === TRUE) {\n        $zip->extractTo($extractTo);\n        $zip->close();\n        chmod($extractTo, 0777);\n    }\n}\n\n\nfunction delTree($dir)\n{\n    $files = array_diff(scandir($dir), array('.', '..'));\n    foreach ($files as $file) {\n        (is_dir(\"$dir/$file\")) ? delTree(\"$dir/$file\") : unlink(\"$dir/$file\");\n    }\n    return rmdir($dir);\n}\n";
+export default _default;

package/lib/steps/run-wp-installation-wizard.d.ts

@@ -0,0 +1,16 @@
+import { StepHandler } from '.';
+export interface RunWpInstallationWizardStep {
+    step: 'runWpInstallationWizard';
+    options: WordPressInstallationOptions;
+}
+export interface WordPressInstallationOptions {
+    adminUsername?: string;
+    adminPassword?: string;
+}
+/**
+ * Installs WordPress
+ *
+ * @param playground The playground client.
+ * @param options Installation options.
+ */
+export declare const runWpInstallationWizard: StepHandler<RunWpInstallationWizardStep>;

package/lib/steps/site-data.d.ts

@@ -0,0 +1,12 @@
+import { StepHandler } from '.';
+export type SetSiteOptionsStep = {
+    step: 'setSiteOptions';
+    options: Record<string, unknown>;
+};
+export declare const setSiteOptions: StepHandler<SetSiteOptionsStep>;
+export interface UpdateUserMetaStep {
+    step: 'updateUserMeta';
+    meta: Record<string, unknown>;
+    userId: number;
+}
+export declare const updateUserMeta: StepHandler<UpdateUserMetaStep>;