@blockbite/ui 1.0.0

package/dist/node_modules/@wordpress/token-list/build-module/index.js

@@ -0,0 +1,166 @@
+class s {
+  /**
+   * Constructs a new instance of TokenList.
+   *
+   * @param initialValue Initial value to assign.
+   */
+  constructor(r = "") {
+    this._currentValue = "", this._valueAsArray = [], this.value = r;
+  }
+  entries(...r) {
+    return this._valueAsArray.entries(...r);
+  }
+  forEach(...r) {
+    return this._valueAsArray.forEach(...r);
+  }
+  keys(...r) {
+    return this._valueAsArray.keys(...r);
+  }
+  values(...r) {
+    return this._valueAsArray.values(...r);
+  }
+  /**
+   * Returns the associated set as string.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-value
+   *
+   * @return Token set as string.
+   */
+  get value() {
+    return this._currentValue;
+  }
+  /**
+   * Replaces the associated set with a new string value.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-value
+   *
+   * @param value New token set as string.
+   */
+  set value(r) {
+    r = String(r), this._valueAsArray = [...new Set(r.split(/\s+/g).filter(Boolean))], this._currentValue = this._valueAsArray.join(" ");
+  }
+  /**
+   * Returns the number of tokens.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-length
+   *
+   * @return Number of tokens.
+   */
+  get length() {
+    return this._valueAsArray.length;
+  }
+  /**
+   * Returns the stringified form of the TokenList.
+   *
+   * @see https://dom.spec.whatwg.org/#DOMTokenList-stringification-behavior
+   * @see https://www.ecma-international.org/ecma-262/9.0/index.html#sec-tostring
+   *
+   * @return Token set as string.
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Returns an iterator for the TokenList, iterating items of the set.
+   *
+   * @see https://dom.spec.whatwg.org/#domtokenlist
+   *
+   * @return TokenList iterator.
+   */
+  *[Symbol.iterator]() {
+    return yield* this._valueAsArray;
+  }
+  /**
+   * Returns the token with index `index`.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-item
+   *
+   * @param index Index at which to return token.
+   *
+   * @return Token at index.
+   */
+  item(r) {
+    return this._valueAsArray[r];
+  }
+  /**
+   * Returns true if `token` is present, and false otherwise.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-contains
+   *
+   * @param item Token to test.
+   *
+   * @return Whether token is present.
+   */
+  contains(r) {
+    return this._valueAsArray.indexOf(r) !== -1;
+  }
+  /**
+   * Adds all arguments passed, except those already present.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-add
+   *
+   * @param items Items to add.
+   */
+  add(...r) {
+    this.value += " " + r.join(" ");
+  }
+  /**
+   * Removes arguments passed, if they are present.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-remove
+   *
+   * @param items Items to remove.
+   */
+  remove(...r) {
+    this.value = this._valueAsArray.filter((e) => !r.includes(e)).join(" ");
+  }
+  /**
+   * If `force` is not given, "toggles" `token`, removing it if it’s present
+   * and adding it if it’s not present. If `force` is true, adds token (same
+   * as add()). If force is false, removes token (same as remove()). Returns
+   * true if `token` is now present, and false otherwise.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-toggle
+   *
+   * @param token   Token to toggle.
+   * @param [force] Presence to force.
+   *
+   * @return Whether token is present after toggle.
+   */
+  toggle(r, e) {
+    return e === void 0 && (e = !this.contains(r)), e ? this.add(r) : this.remove(r), e;
+  }
+  /**
+   * Replaces `token` with `newToken`. Returns true if `token` was replaced
+   * with `newToken`, and false otherwise.
+   *
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-replace
+   *
+   * @param token    Token to replace with `newToken`.
+   * @param newToken Token to use in place of `token`.
+   *
+   * @return Whether replacement occurred.
+   */
+  replace(r, e) {
+    return this.contains(r) ? (this.remove(r), this.add(e), !0) : !1;
+  }
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  /**
+   * Returns true if `token` is in the associated attribute’s supported
+   * tokens. Returns false otherwise.
+   *
+   * Always returns `true` in this implementation.
+   *
+   * @param _token
+   * @see https://dom.spec.whatwg.org/#dom-domtokenlist-supports
+   *
+   * @return Whether token is supported.
+   */
+  supports(r) {
+    return !0;
+  }
+  /* eslint-enable @typescript-eslint/no-unused-vars */
+}
+export {
+  s as default
+};

package/dist/node_modules/@wordpress/upload-media/build-module/components/provider/index.js

@@ -0,0 +1,22 @@
+import { useEffect as s } from "@wordpress/element";
+import m from "./with-registry-provider.js";
+import { unlock as n } from "../../lock-unlock.js";
+import { store as p } from "../../store/index.js";
+import { j as o } from "../../../../../react/jsx-runtime.js";
+import f from "../../../../data/build-module/components/use-dispatch/use-dispatch.js";
+const h = m((e) => {
+  const {
+    children: i,
+    settings: r
+  } = e, {
+    updateSettings: t
+  } = n(f(p));
+  return s(() => {
+    t(r);
+  }, [r, t]), /* @__PURE__ */ o.jsx(o.Fragment, {
+    children: i
+  });
+});
+export {
+  h as default
+};

package/dist/node_modules/@wordpress/upload-media/build-module/components/provider/with-registry-provider.js

@@ -0,0 +1,33 @@
+import { useState as f } from "@wordpress/element";
+import { storeConfig as n } from "../../store/index.js";
+import { STORE_NAME as u } from "../../store/constants.js";
+import { j as s } from "../../../../../react/jsx-runtime.js";
+import g from "../../../../data/build-module/components/registry-provider/use-registry.js";
+import R from "../../../../data/build-module/components/registry-provider/context.js";
+import { createRegistry as a } from "../../../../data/build-module/registry.js";
+import { createHigherOrderComponent as c } from "../../../../compose/build-module/utils/create-higher-order-component/index.js";
+function p(e, t, i) {
+  if (!i)
+    return t;
+  let r = e.get(t);
+  return r || (r = a({}, t), r.registerStore(u, n), e.set(t, r)), r;
+}
+const b = c((e) => ({
+  useSubRegistry: t = !0,
+  ...i
+}) => {
+  const r = g(), [m] = f(() => /* @__PURE__ */ new WeakMap()), o = p(m, r, t);
+  return o === r ? /* @__PURE__ */ s.jsx(e, {
+    registry: r,
+    ...i
+  }) : /* @__PURE__ */ s.jsx(R, {
+    value: o,
+    children: /* @__PURE__ */ s.jsx(e, {
+      registry: o,
+      ...i
+    })
+  });
+}, "withRegistryProvider");
+export {
+  b as default
+};

package/dist/node_modules/@wordpress/upload-media/build-module/get-mime-types-array.js

@@ -0,0 +1,9 @@
+function l(t) {
+  return t ? Object.entries(t).flatMap(([r, n]) => {
+    const [e] = n.split("/"), s = r.split("|");
+    return [n, ...s.map((i) => `${e}/${i}`)];
+  }) : null;
+}
+export {
+  l as getMimeTypesArray
+};

package/dist/node_modules/@wordpress/upload-media/build-module/lock-unlock.js

@@ -0,0 +1,7 @@
+import { __dangerousOptInToUnstableAPIsOnlyForCoreModules as e } from "../../private-apis/build-module/implementation.js";
+const {
+  unlock: r
+} = e("I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", "@wordpress/upload-media");
+export {
+  r as unlock
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/actions.js

@@ -0,0 +1,69 @@
+import { Type as p } from "./types.js";
+import { validateMimeType as s } from "../validate-mime-type.js";
+import { validateMimeTypeForUser as u } from "../validate-mime-type-for-user.js";
+import { validateFileSize as y } from "../validate-file-size.js";
+import I from "../../../../uuid/dist/esm-browser/v4.js";
+function S({
+  files: o,
+  onChange: e,
+  onSuccess: l,
+  onError: a,
+  onBatchSuccess: n,
+  additionalData: t,
+  allowedTypes: c
+}) {
+  return async ({
+    select: m,
+    dispatch: f
+  }) => {
+    const d = I();
+    for (const i of o) {
+      try {
+        s(i, c), u(i, m.getSettings().allowedMimeTypes);
+      } catch (r) {
+        a?.(r);
+        continue;
+      }
+      try {
+        y(i, m.getSettings().maxUploadFileSize);
+      } catch (r) {
+        a?.(r);
+        continue;
+      }
+      f.addItem({
+        file: i,
+        batchId: d,
+        onChange: e,
+        onSuccess: l,
+        onBatchSuccess: n,
+        onError: a,
+        additionalData: t
+      });
+    }
+  };
+}
+function T(o, e, l = !1) {
+  return async ({
+    select: a,
+    dispatch: n
+  }) => {
+    const t = a.getItem(o);
+    if (t) {
+      if (t.abortController?.abort(), !l) {
+        const {
+          onError: c
+        } = t;
+        c?.(e ?? new Error("Upload cancelled")), !c && e && console.error("Upload cancelled", e);
+      }
+      n({
+        type: p.Cancel,
+        id: o,
+        error: e
+      }), n.removeItem(o), n.revokeBlobUrls(o), t.batchId && a.isBatchUploaded(t.batchId) && t.onBatchSuccess?.();
+    }
+  };
+}
+export {
+  S as addItems,
+  T as cancelItem
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/constants.js

@@ -0,0 +1,4 @@
+const o = "core/upload-media";
+export {
+  o as STORE_NAME
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/index.js

@@ -0,0 +1,25 @@
+import { register as m } from "../../../data/build-module/index.js";
+import o from "./reducer.js";
+import * as t from "./selectors.js";
+import * as s from "./private-selectors.js";
+import * as e from "./actions.js";
+import * as p from "./private-actions.js";
+import { unlock as i } from "../lock-unlock.js";
+import { STORE_NAME as c } from "./constants.js";
+import a from "../../../data/build-module/redux-store/index.js";
+const S = {
+  reducer: o,
+  selectors: t,
+  actions: e
+}, r = a(c, {
+  reducer: o,
+  selectors: t,
+  actions: e
+});
+m(r);
+i(r).registerPrivateActions(p);
+i(r).registerPrivateSelectors(s);
+export {
+  r as store,
+  S as storeConfig
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/private-actions.js

@@ -0,0 +1,196 @@
+import { createBlobURL as U, isBlobURL as g, revokeBlobURL as B } from "../../../blob/build-module/index.js";
+import { convertBlobToFile as d, cloneFile as v } from "../utils.js";
+import { StubFile as S } from "../stub-file.js";
+import { Type as i, OperationType as u, ItemStatus as A } from "./types.js";
+import O from "../../../../uuid/dist/esm-browser/v4.js";
+function L({
+  file: e,
+  batchId: r,
+  onChange: t,
+  onSuccess: n,
+  onBatchSuccess: o,
+  onError: c,
+  additionalData: m = {},
+  sourceUrl: p,
+  sourceAttachmentId: s,
+  abortController: a,
+  operations: I
+}) {
+  return async ({
+    dispatch: f
+  }) => {
+    const y = O(), l = d(e);
+    let b;
+    l instanceof S || (b = U(l), f({
+      type: i.CacheBlobUrl,
+      id: y,
+      blobUrl: b
+    })), f({
+      type: i.Add,
+      item: {
+        id: y,
+        batchId: r,
+        status: A.Processing,
+        sourceFile: v(l),
+        file: l,
+        attachment: {
+          url: b
+        },
+        additionalData: {
+          convert_format: !1,
+          ...m
+        },
+        onChange: t,
+        onSuccess: n,
+        onBatchSuccess: o,
+        onError: c,
+        sourceUrl: p,
+        sourceAttachmentId: s,
+        abortController: a || new AbortController(),
+        operations: Array.isArray(I) ? I : [u.Prepare]
+      }
+    }), f.processItem(y);
+  };
+}
+function Q(e) {
+  return async ({
+    select: r,
+    dispatch: t
+  }) => {
+    if (r.isPaused())
+      return;
+    const n = r.getItem(e), {
+      attachment: o,
+      onChange: c,
+      onSuccess: m,
+      onBatchSuccess: p,
+      batchId: s
+    } = n, a = Array.isArray(n.operations?.[0]) ? n.operations[0][0] : n.operations?.[0];
+    if (o && c?.([o]), !a) {
+      o && m?.([o]), t.revokeBlobUrls(e), s && r.isBatchUploaded(s) && p?.();
+      return;
+    }
+    if (a)
+      switch (t({
+        type: i.OperationStart,
+        id: e,
+        operation: a
+      }), a) {
+        case u.Prepare:
+          t.prepareItem(n.id);
+          break;
+        case u.Upload:
+          t.uploadItem(e);
+          break;
+      }
+  };
+}
+function h() {
+  return {
+    type: i.PauseQueue
+  };
+}
+function D() {
+  return async ({
+    select: e,
+    dispatch: r
+  }) => {
+    r({
+      type: i.ResumeQueue
+    });
+    for (const t of e.getAllItems())
+      r.processItem(t.id);
+  };
+}
+function T(e) {
+  return async ({
+    select: r,
+    dispatch: t
+  }) => {
+    r.getItem(e) && t({
+      type: i.Remove,
+      id: e
+    });
+  };
+}
+function w(e, r) {
+  return async ({
+    dispatch: t
+  }) => {
+    t({
+      type: i.OperationFinish,
+      id: e,
+      item: r
+    }), t.processItem(e);
+  };
+}
+function x(e) {
+  return async ({
+    dispatch: r
+  }) => {
+    const t = [u.Upload];
+    r({
+      type: i.AddOperations,
+      id: e,
+      operations: t
+    }), r.finishOperation(e, {});
+  };
+}
+function E(e) {
+  return async ({
+    select: r,
+    dispatch: t
+  }) => {
+    const n = r.getItem(e);
+    r.getSettings().mediaUpload({
+      filesList: [n.file],
+      additionalData: n.additionalData,
+      signal: n.abortController?.signal,
+      onFileChange: ([o]) => {
+        g(o.url) || t.finishOperation(e, {
+          attachment: o
+        });
+      },
+      onSuccess: ([o]) => {
+        t.finishOperation(e, {
+          attachment: o
+        });
+      },
+      onError: (o) => {
+        t.cancelItem(e, o);
+      }
+    });
+  };
+}
+function _(e) {
+  return async ({
+    select: r,
+    dispatch: t
+  }) => {
+    const n = r.getBlobUrls(e);
+    for (const o of n)
+      B(o);
+    t({
+      type: i.RevokeBlobUrls,
+      id: e
+    });
+  };
+}
+function j(e) {
+  return {
+    type: i.UpdateSettings,
+    settings: e
+  };
+}
+export {
+  L as addItem,
+  w as finishOperation,
+  h as pauseQueue,
+  x as prepareItem,
+  Q as processItem,
+  T as removeItem,
+  D as resumeQueue,
+  _ as revokeBlobUrls,
+  j as updateSettings,
+  E as uploadItem
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/private-selectors.js

@@ -0,0 +1,31 @@
+import { OperationType as o, ItemStatus as a } from "./types.js";
+function s(t) {
+  return t.queue;
+}
+function i(t, e) {
+  return t.queue.find((u) => u.id === e);
+}
+function d(t, e) {
+  return t.queue.filter((n) => e === n.batchId).length === 0;
+}
+function l(t, e) {
+  return t.queue.some((u) => u.currentOperation === o.Upload && u.additionalData.post === e);
+}
+function c(t, e) {
+  return t.queue.find((u) => u.status === a.Paused && u.additionalData.post === e);
+}
+function p(t) {
+  return t.queueStatus === "paused";
+}
+function f(t, e) {
+  return t.blobUrls[e] || [];
+}
+export {
+  s as getAllItems,
+  f as getBlobUrls,
+  i as getItem,
+  c as getPausedUploadForPost,
+  d as isBatchUploaded,
+  p as isPaused,
+  l as isUploadingToPost
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/reducer.js

@@ -0,0 +1,114 @@
+import { Type as n } from "./types.js";
+const l = () => {
+}, s = {
+  queue: [],
+  queueStatus: "active",
+  blobUrls: {},
+  settings: {
+    mediaUpload: l
+  }
+};
+function p(r = s, u = {
+  type: n.Unknown
+}) {
+  switch (u.type) {
+    case n.PauseQueue:
+      return {
+        ...r,
+        queueStatus: "paused"
+      };
+    case n.ResumeQueue:
+      return {
+        ...r,
+        queueStatus: "active"
+      };
+    case n.Add:
+      return {
+        ...r,
+        queue: [...r.queue, u.item]
+      };
+    case n.Cancel:
+      return {
+        ...r,
+        queue: r.queue.map((e) => e.id === u.id ? {
+          ...e,
+          error: u.error
+        } : e)
+      };
+    case n.Remove:
+      return {
+        ...r,
+        queue: r.queue.filter((e) => e.id !== u.id)
+      };
+    case n.OperationStart:
+      return {
+        ...r,
+        queue: r.queue.map((e) => e.id === u.id ? {
+          ...e,
+          currentOperation: u.operation
+        } : e)
+      };
+    case n.AddOperations:
+      return {
+        ...r,
+        queue: r.queue.map((e) => e.id !== u.id ? e : {
+          ...e,
+          operations: [...e.operations || [], ...u.operations]
+        })
+      };
+    case n.OperationFinish:
+      return {
+        ...r,
+        queue: r.queue.map((e) => {
+          if (e.id !== u.id)
+            return e;
+          const d = e.operations ? e.operations.slice(1) : [], o = e.attachment || u.item.attachment ? {
+            ...e.attachment,
+            ...u.item.attachment
+          } : void 0;
+          return {
+            ...e,
+            currentOperation: void 0,
+            operations: d,
+            ...u.item,
+            attachment: o,
+            additionalData: {
+              ...e.additionalData,
+              ...u.item.additionalData
+            }
+          };
+        })
+      };
+    case n.CacheBlobUrl: {
+      const e = r.blobUrls[u.id] || [];
+      return {
+        ...r,
+        blobUrls: {
+          ...r.blobUrls,
+          [u.id]: [...e, u.blobUrl]
+        }
+      };
+    }
+    case n.RevokeBlobUrls: {
+      const e = {
+        ...r.blobUrls
+      };
+      return delete e[u.id], {
+        ...r,
+        blobUrls: e
+      };
+    }
+    case n.UpdateSettings:
+      return {
+        ...r,
+        settings: {
+          ...r.settings,
+          ...u.settings
+        }
+      };
+  }
+  return r;
+}
+export {
+  p as default
+};

package/dist/node_modules/@wordpress/upload-media/build-module/store/selectors.js

@@ -0,0 +1,22 @@
+function u(e) {
+  return e.queue;
+}
+function r(e) {
+  return e.queue.length >= 1;
+}
+function o(e, n) {
+  return e.queue.some((t) => t.attachment?.url === n || t.sourceUrl === n);
+}
+function i(e, n) {
+  return e.queue.some((t) => t.attachment?.id === n || t.sourceAttachmentId === n);
+}
+function s(e) {
+  return e.settings;
+}
+export {
+  u as getItems,
+  s as getSettings,
+  r as isUploading,
+  i as isUploadingById,
+  o as isUploadingByUrl
+};