@archilogic/extension-sdk 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# @archilogic/extension-sdk
+
+## 0.2.1
+
+### Patch Changes
+
+- 5c5bf7b: fix(extension-sdk): bundle all types
+
+## 0.2.0
+
+### Minor Changes
+
+- 52b7f4d: feat(extension-sdk): allow to select return fields in layout query methods
+
+## 0.1.0
+
+### Minor Changes
+
+- a2d70e5: feat(extension-sdk): add plugin and host api with method types
+
+### Patch Changes
+
+- a2d70e5: chore: init package

package/README.md

@@ -0,0 +1,29 @@
+# @archilogic/extension-sdk
+
+## Description
+
+The Plugin SDK allows to create plugins for the Archilogic editor.
+
+## Installation
+
+```
+npm install
+```
+
+## Run tests
+
+```
+npm run test
+```
+
+## Type check, formatting and linting
+
+```
+npm run codecheck
+```
+
+## Build
+
+```
+npm run build
+```

package/dist/extension-sdk.js

@@ -0,0 +1,584 @@
+var we = Object.defineProperty;
+var Q = (e) => {
+  throw TypeError(e);
+};
+var Ee = (e, t, r) => t in e ? we(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var P = (e, t, r) => Ee(e, typeof t != "symbol" ? t + "" : t, r), Z = (e, t, r) => t.has(e) || Q("Cannot " + r);
+var s = (e, t, r) => (Z(e, t, "read from private field"), r ? r.call(e) : t.get(e)), f = (e, t, r) => t.has(e) ? Q("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), I = (e, t, r, a) => (Z(e, t, "write to private field"), a ? a.call(e, r) : t.set(e, r), r);
+var Pe = class extends Error {
+  constructor(t, r) {
+    super(r);
+    P(this, "code");
+    this.name = "PenpalError", this.code = t;
+  }
+}, w = Pe, Ie = (e) => ({
+  name: e.name,
+  message: e.message,
+  stack: e.stack,
+  penpalCode: e instanceof w ? e.code : void 0
+}), Ae = ({
+  name: e,
+  message: t,
+  stack: r,
+  penpalCode: a
+}) => {
+  const n = a ? new w(a, t) : new Error(t);
+  return n.name = e, n.stack = r, n;
+}, Se = Symbol("Reply"), B, ae, Ce = (ae = class {
+  constructor(e, t) {
+    P(this, "value");
+    P(this, "transferables");
+    // Allows TypeScript to distinguish between an actual instance of this
+    // class versus an object that looks structurally similar.
+    // eslint-disable-next-line no-unused-private-class-members
+    f(this, B, Se);
+    this.value = e, this.transferables = t == null ? void 0 : t.transferables;
+  }
+}, B = new WeakMap(), ae), me = Ce, M = "penpal", W = (e) => typeof e == "object" && e !== null, ce = (e) => typeof e == "function", Re = (e) => W(e) && e.namespace === M, j = (e) => e.type === "SYN", X = (e) => e.type === "ACK1", z = (e) => e.type === "ACK2", de = (e) => e.type === "CALL", le = (e) => e.type === "REPLY", Ne = (e) => e.type === "DESTROY", ue = (e, t = []) => {
+  const r = [];
+  for (const a of Object.keys(e)) {
+    const n = e[a];
+    ce(n) ? r.push([...t, a]) : W(n) && r.push(
+      ...ue(n, [...t, a])
+    );
+  }
+  return r;
+}, _e = (e, t) => {
+  const r = e.reduce(
+    (a, n) => W(a) ? a[n] : void 0,
+    t
+  );
+  return ce(r) ? r : void 0;
+}, C = (e) => e.join("."), ee = (e, t, r) => ({
+  namespace: M,
+  channel: e,
+  type: "REPLY",
+  callId: t,
+  isError: !0,
+  ...r instanceof Error ? { value: Ie(r), isSerializedErrorInstance: !0 } : { value: r }
+}), Te = (e, t, r, a) => {
+  let n = !1;
+  const d = async (l) => {
+    if (n || !de(l))
+      return;
+    a == null || a(`Received ${C(l.methodPath)}() call`, l);
+    const { methodPath: v, args: h, id: o } = l;
+    let i, E;
+    try {
+      const u = _e(v, t);
+      if (!u)
+        throw new w(
+          "METHOD_NOT_FOUND",
+          `Method \`${C(v)}\` is not found.`
+        );
+      let p = await u(...h);
+      p instanceof me && (E = p.transferables, p = await p.value), i = {
+        namespace: M,
+        channel: r,
+        type: "REPLY",
+        callId: o,
+        value: p
+      };
+    } catch (u) {
+      i = ee(r, o, u);
+    }
+    if (!n)
+      try {
+        a == null || a(`Sending ${C(v)}() reply`, i), e.sendMessage(i, E);
+      } catch (u) {
+        throw u.name === "DataCloneError" && (i = ee(r, o, u), a == null || a(`Sending ${C(v)}() reply`, i), e.sendMessage(i)), u;
+      }
+  };
+  return e.addMessageHandler(d), () => {
+    n = !0, e.removeMessageHandler(d);
+  };
+}, De = Te, se, he = ((se = crypto.randomUUID) == null ? void 0 : se.bind(crypto)) ?? (() => new Array(4).fill(0).map(
+  () => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)
+).join("-")), Le = Symbol("CallOptions"), J, ie, be = (ie = class {
+  constructor(e) {
+    P(this, "transferables");
+    P(this, "timeout");
+    // Allows TypeScript to distinguish between an actual instance of this
+    // class versus an object that looks structurally similar.
+    // eslint-disable-next-line no-unused-private-class-members
+    f(this, J, Le);
+    this.transferables = e == null ? void 0 : e.transferables, this.timeout = e == null ? void 0 : e.timeout;
+  }
+}, J = new WeakMap(), ie), ke = be, Oe = /* @__PURE__ */ new Set(["apply", "call", "bind"]), pe = (e, t, r = []) => new Proxy(
+  r.length ? () => {
+  } : /* @__PURE__ */ Object.create(null),
+  {
+    get(a, n) {
+      if (n !== "then")
+        return r.length && Oe.has(n) ? Reflect.get(a, n) : pe(e, t, [...r, n]);
+    },
+    apply(a, n, d) {
+      return e(r, d);
+    }
+  }
+), te = (e) => new w(
+  "CONNECTION_DESTROYED",
+  `Method call ${C(
+    e
+  )}() failed due to destroyed connection`
+), He = (e, t, r) => {
+  let a = !1;
+  const n = /* @__PURE__ */ new Map(), d = (h) => {
+    if (!le(h))
+      return;
+    const { callId: o, value: i, isError: E, isSerializedErrorInstance: u } = h, p = n.get(o);
+    p && (n.delete(o), r == null || r(
+      `Received ${C(p.methodPath)}() call`,
+      h
+    ), E ? p.reject(
+      u ? Ae(i) : i
+    ) : p.resolve(i));
+  };
+  return e.addMessageHandler(d), {
+    remoteProxy: pe((h, o) => {
+      if (a)
+        throw te(h);
+      const i = he(), E = o[o.length - 1], u = E instanceof ke, { timeout: p, transferables: g } = u ? E : {}, F = u ? o.slice(0, -1) : o;
+      return new Promise((Y, O) => {
+        const K = p !== void 0 ? window.setTimeout(() => {
+          n.delete(i), O(
+            new w(
+              "METHOD_CALL_TIMEOUT",
+              `Method call ${C(
+                h
+              )}() timed out after ${p}ms`
+            )
+          );
+        }, p) : void 0;
+        n.set(i, { methodPath: h, resolve: Y, reject: O, timeoutId: K });
+        try {
+          const T = {
+            namespace: M,
+            channel: t,
+            type: "CALL",
+            id: i,
+            methodPath: h,
+            args: F
+          };
+          r == null || r(`Sending ${C(h)}() call`, T), e.sendMessage(T, g);
+        } catch (T) {
+          O(
+            new w("TRANSMISSION_FAILED", T.message)
+          );
+        }
+      });
+    }, r),
+    destroy: () => {
+      a = !0, e.removeMessageHandler(d);
+      for (const { methodPath: h, reject: o, timeoutId: i } of n.values())
+        clearTimeout(i), o(te(h));
+      n.clear();
+    }
+  };
+}, xe = He, Fe = () => {
+  let e, t;
+  return {
+    promise: new Promise((a, n) => {
+      e = a, t = n;
+    }),
+    resolve: e,
+    reject: t
+  };
+}, Ye = Fe, $e = class extends Error {
+  constructor(e) {
+    super(
+      `You've hit a bug in Penpal. Please file an issue with the following information: ${e}`
+    );
+  }
+}, U = $e, G = "deprecated-penpal", je = (e) => W(e) && "penpal" in e, Ue = (e) => e.split("."), re = (e) => e.join("."), fe = (e) => new U(
+  `Unexpected message to translate: ${JSON.stringify(e)}`
+), Ve = (e) => {
+  if (e.penpal === "syn")
+    return {
+      namespace: M,
+      channel: void 0,
+      type: "SYN",
+      participantId: G
+    };
+  if (e.penpal === "ack")
+    return {
+      namespace: M,
+      channel: void 0,
+      type: "ACK2"
+    };
+  if (e.penpal === "call")
+    return {
+      namespace: M,
+      channel: void 0,
+      type: "CALL",
+      // Actually converting the ID to a string would break communication.
+      id: e.id,
+      methodPath: Ue(e.methodName),
+      args: e.args
+    };
+  if (e.penpal === "reply")
+    return e.resolution === "fulfilled" ? {
+      namespace: M,
+      channel: void 0,
+      type: "REPLY",
+      // Actually converting the ID to a string would break communication.
+      callId: e.id,
+      value: e.returnValue
+    } : {
+      namespace: M,
+      channel: void 0,
+      type: "REPLY",
+      // Actually converting the ID to a string would break communication.
+      callId: e.id,
+      isError: !0,
+      ...e.returnValueIsError ? {
+        value: e.returnValue,
+        isSerializedErrorInstance: !0
+      } : {
+        value: e.returnValue
+      }
+    };
+  throw fe(e);
+}, We = (e) => {
+  if (X(e))
+    return {
+      penpal: "synAck",
+      methodNames: e.methodPaths.map(re)
+    };
+  if (de(e))
+    return {
+      penpal: "call",
+      // Actually converting the ID to a number would break communication.
+      id: e.id,
+      methodName: re(e.methodPath),
+      args: e.args
+    };
+  if (le(e))
+    return e.isError ? {
+      penpal: "reply",
+      // Actually converting the ID to a number would break communication.
+      id: e.callId,
+      resolution: "rejected",
+      ...e.isSerializedErrorInstance ? {
+        returnValue: e.value,
+        returnValueIsError: !0
+      } : { returnValue: e.value }
+    } : {
+      penpal: "reply",
+      // Actually converting the ID to a number would break communication.
+      id: e.callId,
+      resolution: "fulfilled",
+      returnValue: e.value
+    };
+  throw fe(e);
+}, ge = ({
+  messenger: e,
+  methods: t,
+  timeout: r,
+  channel: a,
+  log: n
+}) => {
+  const d = he();
+  let l;
+  const v = [];
+  let h = !1;
+  const o = ue(t), { promise: i, resolve: E, reject: u } = Ye(), p = r !== void 0 ? setTimeout(() => {
+    u(
+      new w(
+        "CONNECTION_TIMEOUT",
+        `Connection timed out after ${r}ms`
+      )
+    );
+  }, r) : void 0, g = () => {
+    for (const c of v)
+      c();
+  }, F = () => {
+    if (h)
+      return;
+    v.push(De(e, t, a, n));
+    const { remoteProxy: c, destroy: m } = xe(e, a, n);
+    v.push(m), clearTimeout(p), h = !0, E({
+      remoteProxy: c,
+      destroy: g
+    });
+  }, Y = () => {
+    const c = {
+      namespace: M,
+      type: "SYN",
+      channel: a,
+      participantId: d
+    };
+    n == null || n("Sending handshake SYN", c);
+    try {
+      e.sendMessage(c);
+    } catch (m) {
+      u(new w("TRANSMISSION_FAILED", m.message));
+    }
+  }, O = (c) => {
+    if (n == null || n("Received handshake SYN", c), c.participantId === l && // TODO: Used for backward-compatibility. Remove in next major version.
+    l !== G || (l = c.participantId, Y(), !(d > l || // TODO: Used for backward-compatibility. Remove in next major version.
+    l === G)))
+      return;
+    const $ = {
+      namespace: M,
+      channel: a,
+      type: "ACK1",
+      methodPaths: o
+    };
+    n == null || n("Sending handshake ACK1", $);
+    try {
+      e.sendMessage($);
+    } catch (Me) {
+      u(new w("TRANSMISSION_FAILED", Me.message));
+      return;
+    }
+  }, K = (c) => {
+    n == null || n("Received handshake ACK1", c);
+    const m = {
+      namespace: M,
+      channel: a,
+      type: "ACK2"
+    };
+    n == null || n("Sending handshake ACK2", m);
+    try {
+      e.sendMessage(m);
+    } catch ($) {
+      u(new w("TRANSMISSION_FAILED", $.message));
+      return;
+    }
+    F();
+  }, T = (c) => {
+    n == null || n("Received handshake ACK2", c), F();
+  }, q = (c) => {
+    j(c) && O(c), X(c) && K(c), z(c) && T(c);
+  };
+  return e.addMessageHandler(q), v.push(() => e.removeMessageHandler(q)), Y(), i;
+}, Ke = ge, ze = (e) => {
+  let t = !1, r;
+  return (...a) => (t || (t = !0, r = e(...a)), r);
+}, Ge = ze, ne = /* @__PURE__ */ new WeakSet(), Be = ({
+  messenger: e,
+  methods: t = {},
+  timeout: r,
+  channel: a,
+  log: n
+}) => {
+  if (!e)
+    throw new w("INVALID_ARGUMENT", "messenger must be defined");
+  if (ne.has(e))
+    throw new w(
+      "INVALID_ARGUMENT",
+      "A messenger can only be used for a single connection"
+    );
+  ne.add(e);
+  const d = [e.destroy], l = Ge((o) => {
+    if (o) {
+      const i = {
+        namespace: M,
+        channel: a,
+        type: "DESTROY"
+      };
+      try {
+        e.sendMessage(i);
+      } catch {
+      }
+    }
+    for (const i of d)
+      i();
+    n == null || n("Connection destroyed");
+  }), v = (o) => Re(o) && o.channel === a;
+  return {
+    promise: (async () => {
+      try {
+        e.initialize({ log: n, validateReceivedMessage: v }), e.addMessageHandler((E) => {
+          Ne(E) && l(!1);
+        });
+        const { remoteProxy: o, destroy: i } = await Ke({
+          messenger: e,
+          methods: t,
+          timeout: r,
+          channel: a,
+          log: n
+        });
+        return d.push(i), o;
+      } catch (o) {
+        throw l(!0), o;
+      }
+    })(),
+    // Why we don't reject the connection promise when consumer calls destroy():
+    // https://github.com/Aaronius/penpal/issues/51
+    destroy: () => {
+      l(!0);
+    }
+  };
+}, ve = Be, A, R, D, L, N, S, y, _, V, b, H, x, k, oe, Je = (oe = class {
+  constructor({ remoteWindow: e, allowedOrigins: t }) {
+    f(this, A);
+    f(this, R);
+    f(this, D);
+    f(this, L);
+    f(this, N);
+    f(this, S, /* @__PURE__ */ new Set());
+    f(this, y);
+    // TODO: Used for backward-compatibility. Remove in next major version.
+    f(this, _, !1);
+    P(this, "initialize", ({
+      log: e,
+      validateReceivedMessage: t
+    }) => {
+      I(this, D, e), I(this, L, t), window.addEventListener("message", s(this, x));
+    });
+    P(this, "sendMessage", (e, t) => {
+      if (j(e)) {
+        const r = s(this, b).call(this, e);
+        s(this, A).postMessage(e, {
+          targetOrigin: r,
+          transfer: t
+        });
+        return;
+      }
+      if (X(e) || // If the child is using a previous version of Penpal, we need to
+      // downgrade the message and send it through the window rather than
+      // the port because older versions of Penpal don't use MessagePorts.
+      s(this, _)) {
+        const r = s(this, _) ? We(e) : e, a = s(this, b).call(this, e);
+        s(this, A).postMessage(r, {
+          targetOrigin: a,
+          transfer: t
+        });
+        return;
+      }
+      if (z(e)) {
+        const { port1: r, port2: a } = new MessageChannel();
+        I(this, y, r), r.addEventListener("message", s(this, k)), r.start();
+        const n = [a, ...t || []], d = s(this, b).call(this, e);
+        s(this, A).postMessage(e, {
+          targetOrigin: d,
+          transfer: n
+        });
+        return;
+      }
+      if (s(this, y)) {
+        s(this, y).postMessage(e, {
+          transfer: t
+        });
+        return;
+      }
+      throw new U("Port is undefined");
+    });
+    P(this, "addMessageHandler", (e) => {
+      s(this, S).add(e);
+    });
+    P(this, "removeMessageHandler", (e) => {
+      s(this, S).delete(e);
+    });
+    P(this, "destroy", () => {
+      window.removeEventListener("message", s(this, x)), s(this, H).call(this), s(this, S).clear();
+    });
+    f(this, V, (e) => s(this, R).some(
+      (t) => t instanceof RegExp ? t.test(e) : t === e || t === "*"
+    ));
+    f(this, b, (e) => {
+      if (j(e))
+        return "*";
+      if (!s(this, N))
+        throw new U("Concrete remote origin not set");
+      return s(this, N) === "null" && s(this, R).includes("*") ? "*" : s(this, N);
+    });
+    f(this, H, () => {
+      var e, t;
+      (e = s(this, y)) == null || e.removeEventListener("message", s(this, k)), (t = s(this, y)) == null || t.close(), I(this, y, void 0);
+    });
+    f(this, x, ({
+      source: e,
+      origin: t,
+      ports: r,
+      data: a
+    }) => {
+      var n, d, l;
+      if (e === s(this, A) && (je(a) && ((n = s(this, D)) == null || n.call(
+        this,
+        "Please upgrade the child window to the latest version of Penpal."
+      ), I(this, _, !0), a = Ve(a)), !!((d = s(this, L)) != null && d.call(this, a)))) {
+        if (!s(this, V).call(this, t)) {
+          (l = s(this, D)) == null || l.call(
+            this,
+            `Received a message from origin \`${t}\` which did not match allowed origins \`[${s(this, R).join(", ")}]\``
+          );
+          return;
+        }
+        if (j(a) && (s(this, H).call(this), I(this, N, t)), z(a) && // Previous versions of Penpal don't use MessagePorts and do all
+        // communication through the window.
+        !s(this, _)) {
+          if (I(this, y, r[0]), !s(this, y))
+            throw new U("No port received on ACK2");
+          s(this, y).addEventListener("message", s(this, k)), s(this, y).start();
+        }
+        for (const v of s(this, S))
+          v(a);
+      }
+    });
+    f(this, k, ({ data: e }) => {
+      var t;
+      if ((t = s(this, L)) != null && t.call(this, e))
+        for (const r of s(this, S))
+          r(e);
+    });
+    if (!e)
+      throw new w("INVALID_ARGUMENT", "remoteWindow must be defined");
+    I(this, A, e), I(this, R, t != null && t.length ? t : [window.origin]);
+  }
+}, A = new WeakMap(), R = new WeakMap(), D = new WeakMap(), L = new WeakMap(), N = new WeakMap(), S = new WeakMap(), y = new WeakMap(), _ = new WeakMap(), V = new WeakMap(), b = new WeakMap(), H = new WeakMap(), x = new WeakMap(), k = new WeakMap(), oe), ye = Je;
+const Qe = (e, t) => {
+  const r = new ye({
+    remoteWindow: e.contentWindow,
+    // Defaults to the current origin.
+    allowedOrigins: ["http://localhost:3000", "https://archilogic-com.github.io"]
+    // Alternatively,
+    // allowedOrigins: [new Url(iframe.src).origin]
+  });
+  return ve({
+    messenger: r,
+    // Methods the parent window is exposing to the iframe window.
+    methods: t
+  });
+}, Xe = {
+  onPluginConnect: () => {
+  },
+  onPluginDestroy: () => {
+  },
+  onLayoutChange: () => {
+  },
+  onSelectionChange: () => {
+  },
+  onGraphicDrag: () => {
+  },
+  onCanvasClick: () => {
+  }
+}, Ze = (e = {}) => {
+  const t = new ye({
+    remoteWindow: window.parent,
+    // Defaults to the current origin.
+    allowedOrigins: [
+      "http://localhost:4000",
+      "https://app.archilogic.com",
+      "https://testing-app.archilogic.com"
+    ]
+  }), r = ve({
+    messenger: t,
+    // Methods the iframe window is exposing to the parent window.
+    methods: { ...Xe, ...e }
+  });
+  return new Proxy(
+    {},
+    {
+      get(n, d) {
+        return async (...l) => (await r.promise)[d](...l);
+      }
+    }
+  );
+};
+export {
+  Qe as createExtensionConnection,
+  Ze as createHostConnection
+};