dynamic-mui 4.0.0 → 4.0.2

package/dist/index-DueLYDEh.mjs

@@ -0,0 +1,165 @@
+import { t as z, s as k } from "./index-Nx4sGg5x.mjs";
+class M {
+  marshaller;
+  serializer;
+  deserializer;
+  serdeContext;
+  defaultContentType;
+  constructor({ marshaller: i, serializer: n, deserializer: l, serdeContext: c, defaultContentType: y }) {
+    this.marshaller = i, this.serializer = n, this.deserializer = l, this.serdeContext = c, this.defaultContentType = y;
+  }
+  async serializeEventStream({ eventStream: i, requestSchema: n, initialRequest: l }) {
+    const c = this.marshaller, y = n.getEventStreamMember(), p = n.getMemberSchema(y), d = this.serializer, h = this.defaultContentType, u = /* @__PURE__ */ Symbol("initialRequestMarker"), S = {
+      async *[Symbol.asyncIterator]() {
+        if (l) {
+          const r = {
+            ":event-type": { type: "string", value: "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: h }
+          };
+          d.write(n, l);
+          const e = d.flush();
+          yield {
+            [u]: !0,
+            headers: r,
+            body: e
+          };
+        }
+        for await (const r of i)
+          yield r;
+      }
+    };
+    return c.serialize(S, (r) => {
+      if (r[u])
+        return {
+          headers: r.headers,
+          body: r.body
+        };
+      let e = "";
+      for (const s in r)
+        if (s !== "__type") {
+          e = s;
+          break;
+        }
+      const { additionalHeaders: t, body: a, eventType: o, explicitPayloadContentType: m } = this.writeEventBody(e, p, r);
+      return {
+        headers: {
+          ":event-type": { type: "string", value: o },
+          ":message-type": { type: "string", value: "event" },
+          ":content-type": { type: "string", value: m ?? h },
+          ...t
+        },
+        body: a
+      };
+    });
+  }
+  async deserializeEventStream({ response: i, responseSchema: n, initialResponseContainer: l }) {
+    const c = this.marshaller, y = n.getEventStreamMember(), d = n.getMemberSchema(y).getMemberSchemas(), h = /* @__PURE__ */ Symbol("initialResponseMarker"), u = c.deserialize(i.body, async (e) => {
+      let t = "";
+      for (const o in e)
+        if (o !== "__type") {
+          t = o;
+          break;
+        }
+      const a = e[t].body;
+      if (t === "initial-response") {
+        const o = await this.deserializer.read(n, a);
+        return delete o[y], {
+          [h]: !0,
+          ...o
+        };
+      } else if (t in d) {
+        const o = d[t];
+        if (o.isStructSchema()) {
+          const m = {};
+          let f = !1;
+          for (const [s, g] of o.structIterator()) {
+            const { eventHeader: v, eventPayload: w } = g.getMergedTraits();
+            if (f = f || !!(v || w), w)
+              g.isBlobSchema() ? m[s] = a : g.isStringSchema() ? m[s] = (this.serdeContext?.utf8Encoder ?? z)(a) : g.isStructSchema() && (m[s] = await this.deserializer.read(g, a));
+            else if (v) {
+              const b = e[t].headers[s]?.value;
+              b != null && (g.isNumericSchema() ? b && typeof b == "object" && "bytes" in b ? m[s] = BigInt(b.toString()) : m[s] = Number(b) : m[s] = b);
+            }
+          }
+          if (f)
+            return {
+              [t]: m
+            };
+          if (a.byteLength === 0)
+            return {
+              [t]: {}
+            };
+        }
+        return {
+          [t]: await this.deserializer.read(o, a)
+        };
+      } else
+        return {
+          $unknown: e
+        };
+    }), S = u[Symbol.asyncIterator](), r = await S.next();
+    if (r.done)
+      return u;
+    if (r.value?.[h]) {
+      if (!n)
+        throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+      for (const e in r.value)
+        l[e] = r.value[e];
+    }
+    return {
+      async *[Symbol.asyncIterator]() {
+        for (r?.value?.[h] || (yield r.value); ; ) {
+          const { done: e, value: t } = await S.next();
+          if (e)
+            break;
+          yield t;
+        }
+      }
+    };
+  }
+  writeEventBody(i, n, l) {
+    const c = this.serializer;
+    let y = i, p = null, d;
+    const h = n.getSchema()[4].includes(i), u = {};
+    if (h) {
+      const e = n.getMemberSchema(i);
+      if (e.isStructSchema()) {
+        for (const [t, a] of e.structIterator()) {
+          const { eventHeader: o, eventPayload: m } = a.getMergedTraits();
+          if (m)
+            p = t;
+          else if (o) {
+            const f = l[i][t];
+            let s = "binary";
+            a.isNumericSchema() ? (-2) ** 31 <= f && f <= 2 ** 31 - 1 ? s = "integer" : s = "long" : a.isTimestampSchema() ? s = "timestamp" : a.isStringSchema() ? s = "string" : a.isBooleanSchema() && (s = "boolean"), f != null && (u[t] = {
+              type: s,
+              value: f
+            }, delete l[i][t]);
+          }
+        }
+        if (p !== null) {
+          const t = e.getMemberSchema(p);
+          t.isBlobSchema() ? d = "application/octet-stream" : t.isStringSchema() && (d = "text/plain"), c.write(t, l[i][p]);
+        } else
+          c.write(e, l[i]);
+      } else if (e.isUnitSchema())
+        c.write(e, {});
+      else
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+    } else {
+      const [e, t] = l[i];
+      y = e, c.write(15, t);
+    }
+    const S = c.flush() ?? new Uint8Array();
+    return {
+      body: typeof S == "string" ? (this.serdeContext?.utf8Decoder ?? k)(S) : S,
+      eventType: y,
+      explicitPayloadContentType: d,
+      additionalHeaders: u
+    };
+  }
+}
+export {
+  M as EventStreamSerde
+};