eddev 2.0.0-beta.13 → 2.0.0-beta.130

package/wp/@types/fields/types.d.ts

@@ -0,0 +1,115 @@
+type PostStatus = 'publish' | 'draft' | 'pending' | 'private' | 'future' | 'auto-draft' | 'trash';
+export interface CommonPost {
+    status?: PostStatus;
+    title: string | {
+        rendered: string;
+    } | {
+        raw: string;
+    };
+    content: string | {
+        raw: string;
+        rendered: string;
+    };
+    type: string;
+    id: string | number;
+    blocks?: Object[];
+    _links?: Links;
+}
+interface Links {
+    'predecessor-version'?: {
+        href: string;
+        id: number;
+    }[];
+    'version-history'?: {
+        href: string;
+        count: number;
+    }[];
+    [key: string]: {
+        href: string;
+    }[] | undefined;
+}
+interface Author {
+    name: string;
+    avatar_urls: Record<string, string>;
+}
+interface EmbeddedAuthor {
+    author: Author[];
+}
+/**
+ * BasePost interface used for all post types.
+ */
+export interface BasePost extends CommonPost {
+    comment_status?: 'open' | 'closed';
+    excerpt?: string | {
+        raw: string;
+        rendered: string;
+    };
+    meta?: Record<string, any>;
+    parent?: number;
+    password?: string;
+    template?: string;
+    format?: string;
+    featured_media?: number;
+    menu_order?: number;
+    ping_status?: 'open' | 'closed';
+    link?: string;
+    slug?: string;
+    permalink_template?: string;
+    date?: string;
+    modified?: string;
+    author?: number;
+}
+export interface BasePostWithEmbeddedAuthor extends BasePost {
+    _embedded: EmbeddedAuthor;
+}
+export interface Template extends CommonPost {
+    type: 'wp_template';
+    is_custom: boolean;
+    source: string;
+    origin: string;
+    plugin?: string;
+    has_theme_file: boolean;
+    id: string;
+}
+export interface TemplatePart extends CommonPost {
+    type: 'wp_template_part';
+    source: string;
+    origin: string;
+    has_theme_file: boolean;
+    id: string;
+    area: string;
+    plugin?: string;
+}
+export interface Pattern extends CommonPost {
+    slug: string;
+    title: {
+        raw: string;
+    };
+    wp_pattern_sync_status: string;
+}
+export type Post = Template | TemplatePart | Pattern | BasePost;
+export type PostWithPermissions = Post & {
+    permissions: {
+        delete: boolean;
+        update: boolean;
+    };
+};
+export interface PostType {
+    slug: string;
+    viewable: boolean;
+    supports?: {
+        'page-attributes'?: boolean;
+        title?: boolean;
+        revisions?: boolean;
+        author?: string;
+        thumbnail?: string;
+        comments?: string;
+        editor?: boolean;
+    };
+}
+export type CoreDataError = {
+    message?: string;
+    code?: string;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/wp/@types/hooks/createAddHook.d.ts

@@ -0,0 +1,25 @@
+export default createAddHook;
+/**
+ * Adds the hook to the appropriate hooks container.
+ */
+export type AddHook = (hookName: string, namespace: string, callback: import(".").Callback, priority?: number | undefined) => any;
+/**
+ * @callback AddHook
+ *
+ * Adds the hook to the appropriate hooks container.
+ *
+ * @param {string}               hookName      Name of hook to add
+ * @param {string}               namespace     The unique namespace identifying the callback in the form `vendor/plugin/function`.
+ * @param {import('.').Callback} callback      Function to call when the hook is run
+ * @param {number}               [priority=10] Priority of this hook
+ */
+/**
+ * Returns a function which, when invoked, will add a hook.
+ *
+ * @param {import('.').Hooks}    hooks    Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ *
+ * @return {AddHook} Function that adds a new hook.
+ */
+declare function createAddHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey): AddHook;
+//# sourceMappingURL=createAddHook.d.ts.map

package/wp/@types/hooks/createCurrentHook.d.ts

@@ -0,0 +1,13 @@
+export default createCurrentHook;
+/**
+ * Returns a function which, when invoked, will return the name of the
+ * currently running hook, or `null` if no hook of the given type is currently
+ * running.
+ *
+ * @param {import('.').Hooks}    hooks    Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ *
+ * @return {() => string | null} Function that returns the current hook name or null.
+ */
+declare function createCurrentHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey): () => string | null;
+//# sourceMappingURL=createCurrentHook.d.ts.map

package/wp/@types/hooks/createDidHook.d.ts

@@ -0,0 +1,25 @@
+export default createDidHook;
+/**
+ * Returns the number of times an action has been fired.
+ */
+export type DidHook = (hookName: string) => number | undefined;
+/**
+ * @callback DidHook
+ *
+ * Returns the number of times an action has been fired.
+ *
+ * @param {string} hookName The hook name to check.
+ *
+ * @return {number | undefined} The number of times the hook has run.
+ */
+/**
+ * Returns a function which, when invoked, will return the number of times a
+ * hook has been called.
+ *
+ * @param {import('.').Hooks}    hooks    Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ *
+ * @return {DidHook} Function that returns a hook's call count.
+ */
+declare function createDidHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey): DidHook;
+//# sourceMappingURL=createDidHook.d.ts.map

package/wp/@types/hooks/createDoingHook.d.ts

@@ -0,0 +1,26 @@
+export default createDoingHook;
+/**
+ * Returns whether a hook is currently being executed.
+ */
+export type DoingHook = (hookName?: string | undefined) => boolean;
+/**
+ * @callback DoingHook
+ * Returns whether a hook is currently being executed.
+ *
+ * @param {string} [hookName] The name of the hook to check for.  If
+ *                            omitted, will check for any hook being executed.
+ *
+ * @return {boolean} Whether the hook is being executed.
+ */
+/**
+ * Returns a function which, when invoked, will return whether a hook is
+ * currently being executed.
+ *
+ * @param {import('.').Hooks}    hooks    Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ *
+ * @return {DoingHook} Function that returns whether a hook is currently
+ *                     being executed.
+ */
+declare function createDoingHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey): DoingHook;
+//# sourceMappingURL=createDoingHook.d.ts.map

package/wp/@types/hooks/createHasHook.d.ts

@@ -0,0 +1,28 @@
+export default createHasHook;
+/**
+ * Returns whether any handlers are attached for the given hookName and optional namespace.
+ */
+export type HasHook = (hookName: string, namespace?: string | undefined) => boolean;
+/**
+ * @callback HasHook
+ *
+ * Returns whether any handlers are attached for the given hookName and optional namespace.
+ *
+ * @param {string} hookName    The name of the hook to check for.
+ * @param {string} [namespace] Optional. The unique namespace identifying the callback
+ *                             in the form `vendor/plugin/function`.
+ *
+ * @return {boolean} Whether there are handlers that are attached to the given hook.
+ */
+/**
+ * Returns a function which, when invoked, will return whether any handlers are
+ * attached to a particular hook.
+ *
+ * @param {import('.').Hooks}    hooks    Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ *
+ * @return {HasHook} Function that returns whether any handlers are
+ *                   attached to a particular hook and optional namespace.
+ */
+declare function createHasHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey): HasHook;
+//# sourceMappingURL=createHasHook.d.ts.map

package/wp/@types/hooks/createHooks.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Internal class for constructing hooks. Use `createHooks()` function
+ *
+ * Note, it is necessary to expose this class to make its type public.
+ *
+ * @private
+ */
+export class _Hooks {
+    /** @type {import('.').Store} actions */
+    actions: import(".").Store;
+    /** @type {import('.').Store} filters */
+    filters: import(".").Store;
+    addAction: import("./createAddHook").AddHook;
+    addFilter: import("./createAddHook").AddHook;
+    removeAction: import("./createRemoveHook").RemoveHook;
+    removeFilter: import("./createRemoveHook").RemoveHook;
+    hasAction: import("./createHasHook").HasHook;
+    hasFilter: import("./createHasHook").HasHook;
+    removeAllActions: import("./createRemoveHook").RemoveHook;
+    removeAllFilters: import("./createRemoveHook").RemoveHook;
+    doAction: (hookName: string, ...args: unknown[]) => undefined | unknown;
+    doActionAsync: (hookName: string, ...args: unknown[]) => undefined | unknown;
+    applyFilters: (hookName: string, ...args: unknown[]) => undefined | unknown;
+    applyFiltersAsync: (hookName: string, ...args: unknown[]) => undefined | unknown;
+    currentAction: () => string | null;
+    currentFilter: () => string | null;
+    doingAction: import("./createDoingHook").DoingHook;
+    doingFilter: import("./createDoingHook").DoingHook;
+    didAction: import("./createDidHook").DidHook;
+    didFilter: import("./createDidHook").DidHook;
+}
+export default createHooks;
+export type Hooks = _Hooks;
+/** @typedef {_Hooks} Hooks */
+/**
+ * Returns an instance of the hooks object.
+ *
+ * @return {Hooks} A Hooks instance.
+ */
+declare function createHooks(): Hooks;
+//# sourceMappingURL=createHooks.d.ts.map

package/wp/@types/hooks/createRemoveHook.d.ts

@@ -0,0 +1,31 @@
+export default createRemoveHook;
+/**
+ * Removes the specified callback (or all callbacks) from the hook with a given hookName
+ * and namespace.
+ */
+export type RemoveHook = (hookName: string, namespace: string) => number | undefined;
+/**
+ * @callback RemoveHook
+ * Removes the specified callback (or all callbacks) from the hook with a given hookName
+ * and namespace.
+ *
+ * @param {string} hookName  The name of the hook to modify.
+ * @param {string} namespace The unique namespace identifying the callback in the
+ *                           form `vendor/plugin/function`.
+ *
+ * @return {number | undefined} The number of callbacks removed.
+ */
+/**
+ * Returns a function which, when invoked, will remove a specified hook or all
+ * hooks by the given name.
+ *
+ * @param {import('.').Hooks}    hooks             Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ * @param {boolean}              [removeAll=false] Whether to remove all callbacks for a hookName,
+ *                                                 without regard to namespace. Used to create
+ *                                                 `removeAll*` functions.
+ *
+ * @return {RemoveHook} Function that removes hooks.
+ */
+declare function createRemoveHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey, removeAll?: boolean): RemoveHook;
+//# sourceMappingURL=createRemoveHook.d.ts.map

package/wp/@types/hooks/createRunHook.d.ts

@@ -0,0 +1,15 @@
+export default createRunHook;
+/**
+ * Returns a function which, when invoked, will execute all callbacks
+ * registered to a hook of the specified type, optionally returning the final
+ * value of the call chain.
+ *
+ * @param {import('.').Hooks}    hooks          Hooks instance.
+ * @param {import('.').StoreKey} storeKey
+ * @param {boolean}              returnFirstArg Whether each hook callback is expected to return its first argument.
+ * @param {boolean}              async          Whether the hook callback should be run asynchronously
+ *
+ * @return {(hookName:string, ...args: unknown[]) => undefined|unknown} Function that runs hook callbacks.
+ */
+declare function createRunHook(hooks: import(".").Hooks, storeKey: import(".").StoreKey, returnFirstArg: boolean, async: boolean): (hookName: string, ...args: unknown[]) => undefined | unknown;
+//# sourceMappingURL=createRunHook.d.ts.map

package/wp/@types/hooks/index.d.ts

@@ -0,0 +1,90 @@
+/** @typedef {(...args: any[])=>any} Callback */
+/**
+ * @typedef Handler
+ * @property {Callback} callback  The callback
+ * @property {string}   namespace The namespace
+ * @property {number}   priority  The namespace
+ */
+/**
+ * @typedef Hook
+ * @property {Handler[]} handlers Array of handlers
+ * @property {number}    runs     Run counter
+ */
+/**
+ * @typedef Current
+ * @property {string} name         Hook name
+ * @property {number} currentIndex The index
+ */
+/**
+ * @typedef {Record<string, Hook> & {__current: Set<Current>}} Store
+ */
+/**
+ * @typedef {'actions' | 'filters'} StoreKey
+ */
+/**
+ * @typedef {import('./createHooks').Hooks} Hooks
+ */
+export const defaultHooks: import("./createHooks")._Hooks;
+export type Callback = (...args: any[]) => any;
+export type Handler = {
+    /**
+     * The callback
+     */
+    callback: Callback;
+    /**
+     * The namespace
+     */
+    namespace: string;
+    /**
+     * The namespace
+     */
+    priority: number;
+};
+export type Hook = {
+    /**
+     * Array of handlers
+     */
+    handlers: Handler[];
+    /**
+     * Run counter
+     */
+    runs: number;
+};
+export type Current = {
+    /**
+     * Hook name
+     */
+    name: string;
+    /**
+     * The index
+     */
+    currentIndex: number;
+};
+export type Store = Record<string, Hook> & {
+    __current: Set<Current>;
+};
+export type StoreKey = "actions" | "filters";
+export type Hooks = import("./createHooks").Hooks;
+import createHooks from './createHooks';
+export const addAction: import("./createAddHook").AddHook;
+export const addFilter: import("./createAddHook").AddHook;
+export const removeAction: import("./createRemoveHook").RemoveHook;
+export const removeFilter: import("./createRemoveHook").RemoveHook;
+export const hasAction: import("./createHasHook").HasHook;
+export const hasFilter: import("./createHasHook").HasHook;
+export const removeAllActions: import("./createRemoveHook").RemoveHook;
+export const removeAllFilters: import("./createRemoveHook").RemoveHook;
+export const doAction: (hookName: string, ...args: unknown[]) => undefined | unknown;
+export const doActionAsync: (hookName: string, ...args: unknown[]) => undefined | unknown;
+export const applyFilters: (hookName: string, ...args: unknown[]) => undefined | unknown;
+export const applyFiltersAsync: (hookName: string, ...args: unknown[]) => undefined | unknown;
+export const currentAction: () => string | null;
+export const currentFilter: () => string | null;
+export const doingAction: import("./createDoingHook").DoingHook;
+export const doingFilter: import("./createDoingHook").DoingHook;
+export const didAction: import("./createDidHook").DidHook;
+export const didFilter: import("./createDidHook").DidHook;
+export const actions: Store;
+export const filters: Store;
+export { createHooks };
+//# sourceMappingURL=index.d.ts.map

package/wp/@types/hooks/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@wordpress/hooks",
+  "version": "1.0.0",
+  "description": "Types for WordPress hooks",
+  "license": "GPL-2.0-or-later",
+  "main": "",
+  "types": "index.d.ts"
+}

package/wp/@types/hooks/validateHookName.d.ts

@@ -0,0 +1,12 @@
+export default validateHookName;
+/**
+ * Validate a hookName string.
+ *
+ * @param {string} hookName The hook name to validate. Should be a non empty string containing
+ *                          only numbers, letters, dashes, periods and underscores. Also,
+ *                          the hook name cannot begin with `__`.
+ *
+ * @return {boolean} Whether the hook name is valid.
+ */
+declare function validateHookName(hookName: string): boolean;
+//# sourceMappingURL=validateHookName.d.ts.map

package/wp/@types/hooks/validateNamespace.d.ts

@@ -0,0 +1,11 @@
+export default validateNamespace;
+/**
+ * Validate a namespace string.
+ *
+ * @param {string} namespace The namespace to validate - should take the form
+ *                           `vendor/plugin/function`.
+ *
+ * @return {boolean} Whether the namespace is valid.
+ */
+declare function validateNamespace(namespace: string): boolean;
+//# sourceMappingURL=validateNamespace.d.ts.map

package/wp/@types/html-entities/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Decodes the HTML entities from a given string.
+ *
+ * @param {string} html String that contain HTML entities.
+ *
+ * @example
+ * ```js
+ * import { decodeEntities } from '@wordpress/html-entities';
+ *
+ * const result = decodeEntities( 'á' );
+ * console.log( result ); // result will be "á"
+ * ```
+ *
+ * @return {string} The decoded string.
+ */
+export function decodeEntities(html: string): string;
+//# sourceMappingURL=index.d.ts.map

package/wp/@types/html-entities/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@wordpress/html-entities",
+  "version": "1.0.0",
+  "description": "Types for WordPress html-entities",
+  "license": "GPL-2.0-or-later",
+  "main": "",
+  "types": "index.d.ts"
+}

package/wp/@types/i18n/create-i18n.d.ts

@@ -0,0 +1,123 @@
+export function createI18n(initialData?: LocaleData, initialDomain?: string, hooks?: Hooks): I18n;
+export type LocaleData = Record<string, any>;
+/**
+ * Returns locale data by domain in a
+ * Jed-formatted JSON object shape.
+ */
+export type GetLocaleData = (domain?: string) => LocaleData;
+/**
+ * Merges locale data into the Tannin instance by domain. Note that this
+ * function will overwrite the domain configuration. Accepts data in a
+ * Jed-formatted JSON object shape.
+ */
+export type SetLocaleData = (data?: LocaleData, domain?: string) => void;
+/**
+ * Merges locale data into the Tannin instance by domain. Note that this
+ * function will also merge the domain configuration. Accepts data in a
+ * Jed-formatted JSON object shape.
+ */
+export type AddLocaleData = (data?: LocaleData, domain?: string) => void;
+/**
+ * Resets all current Tannin instance locale data and sets the specified
+ * locale data for the domain. Accepts data in a Jed-formatted JSON object shape.
+ */
+export type ResetLocaleData = (data?: LocaleData, domain?: string) => void;
+export type SubscribeCallback = () => void;
+export type UnsubscribeCallback = () => void;
+/**
+ * Subscribes to changes of locale data
+ */
+export type Subscribe = (callback: SubscribeCallback) => UnsubscribeCallback;
+/**
+ * Retrieve the domain to use when calling domain-specific filters.
+ */
+export type GetFilterDomain = (domain?: string) => string;
+/**
+ * Retrieve the translation of text.
+ */
+export type __ = (text: string, domain?: string) => string;
+/**
+ * Retrieve translated string with gettext context.
+ */
+export type _x = (text: string, context: string, domain?: string) => string;
+/**
+ * Translates and retrieves the singular or plural form based on the supplied
+ * number.
+ */
+export type _n = (single: string, plural: string, number: number, domain?: string) => string;
+/**
+ * Translates and retrieves the singular or plural form based on the supplied
+ * number, with gettext context.
+ */
+export type _nx = (single: string, plural: string, number: number, context: string, domain?: string) => string;
+/**
+ * Check if current locale is RTL.
+ *
+ * **RTL (Right To Left)** is a locale property indicating that text is written from right to left.
+ * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common
+ * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages,
+ * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`).
+ */
+export type IsRtl = () => boolean;
+/**
+ * Check if there is a translation for a given string in singular form.
+ */
+export type HasTranslation = (single: string, context?: string, domain?: string) => boolean;
+export type Hooks = import("@wordpress/hooks").Hooks;
+/**
+ * An i18n instance
+ */
+export type I18n = {
+    /**
+     * Returns locale data by domain in a Jed-formatted JSON object shape.
+     */
+    getLocaleData: GetLocaleData;
+    /**
+     * Merges locale data into the Tannin instance by domain. Note that this
+     * function will overwrite the domain configuration. Accepts data in a
+     * Jed-formatted JSON object shape.
+     */
+    setLocaleData: SetLocaleData;
+    /**
+     * Merges locale data into the Tannin instance by domain. Note that this
+     * function will also merge the domain configuration. Accepts data in a
+     * Jed-formatted JSON object shape.
+     */
+    addLocaleData: AddLocaleData;
+    /**
+     * Resets all current Tannin instance locale data and sets the specified
+     * locale data for the domain. Accepts data in a Jed-formatted JSON object shape.
+     */
+    resetLocaleData: ResetLocaleData;
+    /**
+     * Subscribes to changes of Tannin locale data.
+     */
+    subscribe: Subscribe;
+    /**
+     * Retrieve the translation of text.
+     */
+    __: __;
+    /**
+     * Retrieve translated string with gettext context.
+     */
+    _x: _x;
+    /**
+     * Translates and retrieves the singular or plural form based on the supplied
+     * number.
+     */
+    _n: _n;
+    /**
+     * Translates and retrieves the singular or plural form based on the supplied
+     * number, with gettext context.
+     */
+    _nx: _nx;
+    /**
+     * Check if current locale is RTL.
+     */
+    isRTL: IsRtl;
+    /**
+     * Check if there is a translation for a given string.
+     */
+    hasTranslation: HasTranslation;
+};
+//# sourceMappingURL=create-i18n.d.ts.map