@norskvideo/norsk-studio-aws 1.0.0

package/client/info.js

@@ -0,0 +1,793 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// external-global-plugin:react
+var require_react = __commonJS({
+  "external-global-plugin:react"(exports, module) {
+    module.exports = window.React;
+  }
+});
+
+// external-global-plugin:react/jsx-runtime
+var require_jsx_runtime = __commonJS({
+  "external-global-plugin:react/jsx-runtime"(exports, module) {
+    module.exports = window.ReactJsx;
+  }
+});
+
+// build/input.mediaconnect/flow-selection.js
+var flow_selection_exports = {};
+__export(flow_selection_exports, {
+  default: () => flow_selection_default
+});
+function FlowSelection(props) {
+  const [loading, setLoading] = (0, import_react.useState)(true);
+  (0, import_react.useEffect)(() => {
+    const fn = async () => {
+      const result = await fetch("components/input.mediaconnect/flows");
+      if (result.ok && result.body) {
+        const flows2 = await result.json();
+        setFlows(flows2);
+        setLoading(false);
+        if (props.defaultValue)
+          props.onChanged(props.defaultValue);
+      } else {
+        const text = await result.text();
+        throw new Error(text);
+      }
+    };
+    fn().catch(console.error);
+  }, []);
+  const [flows, setFlows] = (0, import_react.useState)([]);
+  if (loading) {
+    return (0, import_jsx_runtime.jsx)("div", { children: "Loading.." });
+  }
+  if (flows.length == 0) {
+    return (0, import_jsx_runtime.jsx)("div", { children: "No flows loaded" });
+  }
+  return (0, import_jsx_runtime.jsx)("div", { children: (0, import_jsx_runtime.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime.jsx)("option", { value: "", children: "---" }, "empty"), flows.map((o, i) => {
+    const val = o.FlowArn;
+    return (0, import_jsx_runtime.jsxs)("option", { value: val, children: ["-", o.Description] }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(e.target.value);
+  }
+}
+var import_jsx_runtime, import_react, flow_selection_default;
+var init_flow_selection = __esm({
+  "build/input.mediaconnect/flow-selection.js"() {
+    "use strict";
+    import_jsx_runtime = __toESM(require_jsx_runtime());
+    import_react = __toESM(require_react());
+    flow_selection_default = FlowSelection;
+  }
+});
+
+// build/input.mediaconnect/output-selection.js
+var output_selection_exports = {};
+__export(output_selection_exports, {
+  default: () => output_selection_default
+});
+function OutputSelection(props) {
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [flow, setFlow] = (0, import_react2.useState)(void 0);
+  (0, import_react2.useEffect)(() => {
+    const fn = async () => {
+      setLoading(true);
+      if (props.latest.flowArn) {
+        const result = await fetch("components/input.mediaconnect/flows/" + props.latest.flowArn);
+        if (result.ok && result.body) {
+          const flow2 = await result.json();
+          setFlow(flow2);
+          setLoading(false);
+          const firstOutput2 = flow2.Outputs?.[0]?.OutputArn;
+          if (firstOutput2 && flow2.Outputs?.length == 1 && firstOutput2 !== props.defaultValue) {
+            props.onChanged(firstOutput2);
+          } else if (props.defaultValue) {
+            props.onChanged(props.defaultValue);
+          }
+        } else {
+          const text = await result.text();
+          throw new Error(text);
+        }
+      }
+    };
+    fn().catch(console.error);
+  }, [props.latest.flowArn]);
+  if (loading) {
+    return (0, import_jsx_runtime2.jsx)("div", { children: "..." });
+  }
+  if (flow == void 0) {
+    return (0, import_jsx_runtime2.jsx)("div", { children: "..." });
+  }
+  if (!flow.Outputs) {
+    return (0, import_jsx_runtime2.jsx)("div", { children: "Flow has no outputs" });
+  }
+  const firstOutput = flow.Outputs?.[0]?.OutputArn;
+  if (firstOutput && flow.Outputs.length == 1) {
+    return (0, import_jsx_runtime2.jsxs)("div", { children: [flow.Outputs[0].ListenerAddress ?? "", ":", flow.Outputs[0].Port ?? 0] });
+  }
+  return (0, import_jsx_runtime2.jsx)("div", { children: (0, import_jsx_runtime2.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime2.jsx)("option", { value: "", children: "---" }, "empty"), flow.Outputs.map((o, i) => {
+    const val = o.OutputArn;
+    return (0, import_jsx_runtime2.jsxs)("option", { value: val, children: [o.Name, "-", o.Description] }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(e.target.value);
+  }
+}
+var import_jsx_runtime2, import_react2, output_selection_default;
+var init_output_selection = __esm({
+  "build/input.mediaconnect/output-selection.js"() {
+    "use strict";
+    import_jsx_runtime2 = __toESM(require_jsx_runtime());
+    import_react2 = __toESM(require_react());
+    output_selection_default = OutputSelection;
+  }
+});
+
+// build/input.mediaconnect/node-view.js
+var node_view_exports = {};
+__export(node_view_exports, {
+  default: () => node_view_default
+});
+function NodeView(props) {
+  const [loading, setLoading] = (0, import_react3.useState)(true);
+  const [flow, setFlow] = (0, import_react3.useState)(void 0);
+  (0, import_react3.useEffect)(() => {
+    if (!props.node.config.flowArn)
+      return;
+    const fn = async () => {
+      const result = await fetch("components/input.mediaconnect/flows/" + props.node.config.flowArn);
+      if (result.ok && result.body) {
+        const flow2 = await result.json();
+        setFlow(flow2);
+        setLoading(false);
+      } else {
+        const text = await result.text();
+        throw new Error(text);
+      }
+    };
+    fn().catch(console.error);
+  }, [props.node.config.flowArn]);
+  const output = flow?.Outputs?.find((o) => o.OutputArn == props.node.config.outputArn);
+  if (loading) {
+    return (0, import_jsx_runtime3.jsx)("div", { children: "..." });
+  }
+  if (!flow) {
+    return (0, import_jsx_runtime3.jsx)("div", { children: "[Error: Failed to load flow]" });
+  }
+  if (!output) {
+    return (0, import_jsx_runtime3.jsx)("div", { children: "[Error: Missing output on flow]" });
+  }
+  return (0, import_jsx_runtime3.jsxs)("div", { children: [(0, import_jsx_runtime3.jsxs)("div", { children: ["Name: ", flow.Name] }), (0, import_jsx_runtime3.jsxs)("div", { children: ["Description: ", flow.Description] }), (0, import_jsx_runtime3.jsxs)("div", { children: ["Protocol: ", output.Transport?.Protocol] }), (0, import_jsx_runtime3.jsxs)("div", { children: ["Address: ", output.ListenerAddress] }), (0, import_jsx_runtime3.jsxs)("div", { children: ["Port: ", output.Port] })] });
+}
+var import_jsx_runtime3, import_react3, node_view_default;
+var init_node_view = __esm({
+  "build/input.mediaconnect/node-view.js"() {
+    "use strict";
+    import_jsx_runtime3 = __toESM(require_jsx_runtime());
+    import_react3 = __toESM(require_react());
+    node_view_default = NodeView;
+  }
+});
+
+// build/output.medialive/channel-selection.js
+var channel_selection_exports = {};
+__export(channel_selection_exports, {
+  default: () => channel_selection_default
+});
+function ChannelSelection(props) {
+  const [loading, setLoading] = (0, import_react5.useState)(true);
+  (0, import_react5.useEffect)(() => {
+    const fn = async () => {
+      const result = await fetch("components/output.medialive/channels");
+      if (result.ok && result.body) {
+        const channels2 = await result.json();
+        setChannels(channels2);
+        setLoading(false);
+        if (props.defaultValue)
+          props.onChanged(props.defaultValue);
+      } else {
+        const text = await result.text();
+        throw new Error(text);
+      }
+    };
+    fn().catch(console.error);
+  }, []);
+  const [channels, setChannels] = (0, import_react5.useState)([]);
+  if (loading) {
+    return (0, import_jsx_runtime4.jsx)("div", { children: "Loading.." });
+  }
+  if (channels.length == 0) {
+    return (0, import_jsx_runtime4.jsx)("div", { children: "No channels loaded" });
+  }
+  return (0, import_jsx_runtime4.jsx)("div", { children: (0, import_jsx_runtime4.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime4.jsx)("option", { value: "", children: "---" }, "empty"), channels.map((o, i) => {
+    const val = o.Id;
+    return (0, import_jsx_runtime4.jsx)("option", { value: val, children: o.Name }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(e.target.value);
+  }
+}
+var import_jsx_runtime4, import_react5, channel_selection_default;
+var init_channel_selection = __esm({
+  "build/output.medialive/channel-selection.js"() {
+    "use strict";
+    import_jsx_runtime4 = __toESM(require_jsx_runtime());
+    import_react5 = __toESM(require_react());
+    channel_selection_default = ChannelSelection;
+  }
+});
+
+// build/output.medialive/input-selection.js
+var input_selection_exports = {};
+__export(input_selection_exports, {
+  default: () => input_selection_default
+});
+function inputSelection(props) {
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const [channels, setChannels] = (0, import_react6.useState)(void 0);
+  const [channel, setChannel] = (0, import_react6.useState)(void 0);
+  (0, import_react6.useEffect)(() => {
+    console.log("Loading channels for input", props);
+    const fn = async () => {
+      setLoading(true);
+      const result = await fetch("components/output.medialive/channels");
+      if (result.ok && result.body) {
+        const channels2 = await result.json();
+        setChannels(channels2);
+        setLoading(false);
+        if (props.defaultValue)
+          props.onChanged(props.defaultValue);
+      } else {
+        const text = await result.text();
+        throw new Error(text);
+      }
+    };
+    fn().catch(console.error);
+  }, []);
+  (0, import_react6.useEffect)(() => {
+    const channel2 = channels?.find((c) => c.Id == props.latest.channelId);
+    setChannel(channel2);
+    const firstInput2 = channel2?.InputAttachments?.[0]?.InputId;
+    if (firstInput2 && channel2?.InputAttachments?.length == 1 && firstInput2 !== props.defaultValue) {
+      props.onChanged(firstInput2);
+    }
+  }, [channels, props.latest.channelId]);
+  if (loading) {
+    return (0, import_jsx_runtime5.jsx)("div", { children: "..." });
+  }
+  if (channel == void 0) {
+    return (0, import_jsx_runtime5.jsx)("div", { children: "..." });
+  }
+  if (!channel.InputAttachments) {
+    return (0, import_jsx_runtime5.jsx)("div", { children: "Channel has no inputs" });
+  }
+  const firstInput = channel.InputAttachments?.[0];
+  if (firstInput && channel.InputAttachments.length == 1) {
+    return (0, import_jsx_runtime5.jsx)("div", { children: firstInput.InputAttachmentName });
+  }
+  return (0, import_jsx_runtime5.jsx)("div", { children: (0, import_jsx_runtime5.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime5.jsx)("option", { value: "", children: "---" }, "empty"), channel.InputAttachments.map((o, i) => {
+    const val = o.InputId;
+    return (0, import_jsx_runtime5.jsx)("option", { value: val, children: o.InputAttachmentName }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(e.target.value);
+  }
+}
+var import_jsx_runtime5, import_react6, input_selection_default;
+var init_input_selection = __esm({
+  "build/output.medialive/input-selection.js"() {
+    "use strict";
+    import_jsx_runtime5 = __toESM(require_jsx_runtime());
+    import_react6 = __toESM(require_react());
+    input_selection_default = inputSelection;
+  }
+});
+
+// build/output.medialive/url-selection.js
+var url_selection_exports = {};
+__export(url_selection_exports, {
+  default: () => url_selection_default
+});
+function UrlSelection(props) {
+  const [loading, setLoading] = (0, import_react7.useState)(true);
+  const [input, setInput] = (0, import_react7.useState)(void 0);
+  (0, import_react7.useEffect)(() => {
+    const fn = async () => {
+      setLoading(true);
+      if (props.latest.inputId) {
+        const result = await fetch("components/output.medialive/inputs/" + props.latest.inputId);
+        if (result.ok && result.body) {
+          const flow = await result.json();
+          setInput(flow);
+          setLoading(false);
+          if (props.defaultValue !== void 0)
+            props.onChanged(props.defaultValue);
+        } else {
+          const text = await result.text();
+          throw new Error(text);
+        }
+      }
+    };
+    fn().catch(console.error);
+  }, [props.latest.inputId]);
+  if (loading) {
+    return (0, import_jsx_runtime6.jsx)("div", { children: "..." });
+  }
+  if (input == void 0) {
+    return (0, import_jsx_runtime6.jsx)("div", { children: "..." });
+  }
+  if (!input.Destinations) {
+    return (0, import_jsx_runtime6.jsx)("div", { children: "Input has no destinations" });
+  }
+  return (0, import_jsx_runtime6.jsx)("div", { children: (0, import_jsx_runtime6.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime6.jsx)("option", { value: "", children: "---" }, "empty"), input.Destinations.map((o, i) => {
+    return (0, import_jsx_runtime6.jsx)("option", { value: i, children: o.Url }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(parseInt(e.target.value, 10));
+  }
+}
+var import_jsx_runtime6, import_react7, url_selection_default;
+var init_url_selection = __esm({
+  "build/output.medialive/url-selection.js"() {
+    "use strict";
+    import_jsx_runtime6 = __toESM(require_jsx_runtime());
+    import_react7 = __toESM(require_react());
+    url_selection_default = UrlSelection;
+  }
+});
+
+// build/output.medialive/node-view.js
+var node_view_exports2 = {};
+__export(node_view_exports2, {
+  default: () => node_view_default2
+});
+function NodeView2(props) {
+  const [loading, setLoading] = (0, import_react8.useState)(true);
+  const [channel, setChannel] = (0, import_react8.useState)(void 0);
+  const [input, setInput] = (0, import_react8.useState)(void 0);
+  (0, import_react8.useEffect)(() => {
+    if (!props.node.config.channelId)
+      return;
+    if (!props.node.config.inputId)
+      return;
+    const fn = async () => {
+      const channels = await fetch("components/output.medialive/channels").then(async (f) => f.json());
+      const input2 = await fetch("components/output.medialive/inputs/" + props.node.config.inputId).then(async (f) => f.json());
+      const channel2 = channels.find((c) => c.Id == props.node.config.channelId);
+      setChannel(channel2);
+      setInput(input2);
+      setLoading(false);
+    };
+    fn().catch(console.error);
+  }, [props.node.config.channelId, props.node.config.inputId]);
+  if (loading) {
+    return (0, import_jsx_runtime7.jsx)("div", { children: "..." });
+  }
+  if (!channel) {
+    return (0, import_jsx_runtime7.jsx)("div", { children: "[Error: Failed to load channel]" });
+  }
+  if (!input) {
+    return (0, import_jsx_runtime7.jsx)("div", { children: "[Error: Missing input on channel]" });
+  }
+  return (0, import_jsx_runtime7.jsxs)("div", { children: [(0, import_jsx_runtime7.jsxs)("div", { children: ["Name: ", channel.Name] }), (0, import_jsx_runtime7.jsxs)("div", { children: ["Input: ", input.Name] }), (0, import_jsx_runtime7.jsxs)("div", { children: ["Url: ", input.Destinations?.[props.node.config.destinationIndex].Url] })] });
+}
+var import_jsx_runtime7, import_react8, node_view_default2;
+var init_node_view2 = __esm({
+  "build/output.medialive/node-view.js"() {
+    "use strict";
+    import_jsx_runtime7 = __toESM(require_jsx_runtime());
+    import_react8 = __toESM(require_react());
+    node_view_default2 = NodeView2;
+  }
+});
+
+// external-global-plugin:hls.js
+var require_hls = __commonJS({
+  "external-global-plugin:hls.js"(exports, module) {
+    module.exports = window.HlsJs;
+  }
+});
+
+// build/output.medialive/inline.js
+var inline_exports = {};
+__export(inline_exports, {
+  default: () => inline_default
+});
+function InlineView({ state, config }) {
+  const url = state.url;
+  const id = config.id;
+  (0, import_react9.useEffect)(() => {
+    if (!url)
+      return;
+    const element = document.getElementById(`${id}-video`);
+    if (import_hls.default.isSupported()) {
+      const hls = new import_hls.default();
+      hls.loadSource(url);
+      hls.attachMedia(element);
+    } else if (element.canPlayType("application/vnd.apple.mpegurl")) {
+      element.src = url;
+    }
+  }, [state.url]);
+  if (!url)
+    return (0, import_jsx_runtime8.jsx)(import_jsx_runtime8.Fragment, { children: "..." });
+  return (0, import_jsx_runtime8.jsx)("div", { className: "preview-outer-container", children: (0, import_jsx_runtime8.jsx)("video", { autoPlay: true, muted: true, id: `${id}-video` }) });
+}
+var import_jsx_runtime8, import_react9, import_hls, inline_default;
+var init_inline = __esm({
+  "build/output.medialive/inline.js"() {
+    "use strict";
+    import_jsx_runtime8 = __toESM(require_jsx_runtime());
+    import_react9 = __toESM(require_react());
+    import_hls = __toESM(require_hls());
+    inline_default = InlineView;
+  }
+});
+
+// build/output.medialive/fullscreen.js
+var fullscreen_exports = {};
+__export(fullscreen_exports, {
+  default: () => fullscreen_default
+});
+function FullscreenView({ state, config }) {
+  const url = state.url;
+  const id = config.id;
+  (0, import_react10.useEffect)(() => {
+    if (!url)
+      return;
+    const element = document.getElementById(`${id}-video`);
+    if (import_hls2.default.isSupported()) {
+      const hls = new import_hls2.default();
+      hls.loadSource(url);
+      hls.attachMedia(element);
+    } else if (element.canPlayType("application/vnd.apple.mpegurl")) {
+      element.src = url;
+    }
+  }, [state.url]);
+  if (!url)
+    return (0, import_jsx_runtime9.jsx)(import_jsx_runtime9.Fragment, { children: "..." });
+  {
+  }
+  return (0, import_jsx_runtime9.jsx)("div", { children: (0, import_jsx_runtime9.jsx)("video", { controls: true, autoPlay: true, muted: true, id: `${id}-video` }) });
+}
+var import_jsx_runtime9, import_react10, import_hls2, fullscreen_default;
+var init_fullscreen = __esm({
+  "build/output.medialive/fullscreen.js"() {
+    "use strict";
+    import_jsx_runtime9 = __toESM(require_jsx_runtime());
+    import_react10 = __toESM(require_react());
+    import_hls2 = __toESM(require_hls());
+    fullscreen_default = FullscreenView;
+  }
+});
+
+// build/processor.aws-transcribe/transcribe-language-selection.js
+var transcribe_language_selection_exports = {};
+__export(transcribe_language_selection_exports, {
+  default: () => transcribe_language_selection_default
+});
+function TranscribeLanguageSelection(props) {
+  const [loading, setLoading] = (0, import_react12.useState)(true);
+  (0, import_react12.useEffect)(() => {
+    const fn = async () => {
+      const result = await fetch("components/processor.aws-transcribe/languages");
+      if (result.ok && result.body) {
+        const languages2 = await result.json();
+        setLanguages(languages2.transcribe);
+        setLoading(false);
+        if (props.defaultValue)
+          props.onChanged(props.defaultValue);
+      } else {
+        const text = await result.text();
+        throw new Error(text);
+      }
+    };
+    fn().catch(console.error);
+  }, []);
+  const [languages, setLanguages] = (0, import_react12.useState)([]);
+  if (loading) {
+    return (0, import_jsx_runtime10.jsx)("div", { children: "Loading.." });
+  }
+  if (languages.length == 0) {
+    return (0, import_jsx_runtime10.jsx)("div", { children: "No flows loaded" });
+  }
+  return (0, import_jsx_runtime10.jsx)("div", { children: (0, import_jsx_runtime10.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime10.jsx)("option", { value: "", children: "---" }, "empty"), languages.map((o, i) => {
+    const val = o.code;
+    return (0, import_jsx_runtime10.jsxs)("option", { value: val, children: [o.name, " (", o.code, ")"] }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(e.target.value);
+  }
+}
+var import_jsx_runtime10, import_react12, transcribe_language_selection_default;
+var init_transcribe_language_selection = __esm({
+  "build/processor.aws-transcribe/transcribe-language-selection.js"() {
+    "use strict";
+    import_jsx_runtime10 = __toESM(require_jsx_runtime());
+    import_react12 = __toESM(require_react());
+    transcribe_language_selection_default = TranscribeLanguageSelection;
+  }
+});
+
+// build/processor.aws-transcribe/translate-language-selection.js
+var translate_language_selection_exports = {};
+__export(translate_language_selection_exports, {
+  default: () => translate_language_selection_default
+});
+function TranslateLanguageSelection(props) {
+  const [loading, setLoading] = (0, import_react13.useState)(true);
+  (0, import_react13.useEffect)(() => {
+    const fn = async () => {
+      const result = await fetch("components/processor.aws-transcribe/languages");
+      if (result.ok && result.body) {
+        const languages2 = await result.json();
+        setLanguages(languages2.translate);
+        setLoading(false);
+        if (props.defaultValue)
+          props.onChanged(props.defaultValue);
+      } else {
+        const text = await result.text();
+        throw new Error(text);
+      }
+    };
+    fn().catch(console.error);
+  }, []);
+  const [languages, setLanguages] = (0, import_react13.useState)([]);
+  if (loading) {
+    return (0, import_jsx_runtime11.jsx)("div", { children: "Loading.." });
+  }
+  if (languages.length == 0) {
+    return (0, import_jsx_runtime11.jsx)("div", { children: "No flows loaded" });
+  }
+  return (0, import_jsx_runtime11.jsx)("div", { children: (0, import_jsx_runtime11.jsxs)("select", { defaultValue: props.defaultValue, className: `node-editor-select-input`, id: props.id, onChange: myOnChange, onBlur: myOnChange, children: [(0, import_jsx_runtime11.jsx)("option", { value: "", children: "---" }, "empty"), languages.map((o, i) => {
+    const val = o.code;
+    return (0, import_jsx_runtime11.jsxs)("option", { value: val, children: [o.name, " (", o.code, ")"] }, i);
+  })] }) });
+  function myOnChange(e) {
+    props.onChanged(e.target.value);
+  }
+}
+var import_jsx_runtime11, import_react13, translate_language_selection_default;
+var init_translate_language_selection = __esm({
+  "build/processor.aws-transcribe/translate-language-selection.js"() {
+    "use strict";
+    import_jsx_runtime11 = __toESM(require_jsx_runtime());
+    import_react13 = __toESM(require_react());
+    translate_language_selection_default = TranslateLanguageSelection;
+  }
+});
+
+// build/input.mediaconnect/info.js
+var import_react4 = __toESM(require_react());
+function info_default({ defineComponent, Av, validation: { Z } }) {
+  const FlowSelection2 = import_react4.default.lazy(async () => Promise.resolve().then(() => (init_flow_selection(), flow_selection_exports)));
+  const OutputSelection2 = import_react4.default.lazy(async () => Promise.resolve().then(() => (init_output_selection(), output_selection_exports)));
+  const NodeView3 = import_react4.default.lazy(async () => Promise.resolve().then(() => (init_node_view(), node_view_exports)));
+  return defineComponent({
+    identifier: "input.mediaconnect",
+    category: "input",
+    name: "Media Connect Input",
+    subscription: {
+      produces: {
+        type: "single-stream",
+        // for now anyway
+        media: Av
+      }
+    },
+    designtime: {
+      node: NodeView3
+    },
+    configForm: {
+      form: {
+        flowArn: {
+          help: "The flow to connect to",
+          hint: {
+            type: "custom",
+            component: FlowSelection2,
+            validation: Z.string().min(1, "Choosing a flow is mandatory")
+          }
+        },
+        outputArn: {
+          help: "Output of the flow to be used",
+          hint: {
+            type: "custom",
+            component: OutputSelection2,
+            validation: Z.string().min(1, "Choosing an output is mandatory")
+          }
+        }
+      }
+    }
+  });
+}
+
+// build/output.medialive/info.js
+var import_react11 = __toESM(require_react());
+function info_default2({ defineComponent, validation: { Z }, All }) {
+  const ChannelSelection2 = import_react11.default.lazy(async () => Promise.resolve().then(() => (init_channel_selection(), channel_selection_exports)));
+  const InputSelection = import_react11.default.lazy(async () => Promise.resolve().then(() => (init_input_selection(), input_selection_exports)));
+  const UrlSelection2 = import_react11.default.lazy(async () => Promise.resolve().then(() => (init_url_selection(), url_selection_exports)));
+  const NodeView3 = import_react11.default.lazy(async () => Promise.resolve().then(() => (init_node_view2(), node_view_exports2)));
+  const InlineView2 = import_react11.default.lazy(async () => Promise.resolve().then(() => (init_inline(), inline_exports)));
+  const FullscreenView2 = import_react11.default.lazy(async () => Promise.resolve().then(() => (init_fullscreen(), fullscreen_exports)));
+  return defineComponent({
+    identifier: "output.medialive",
+    category: "output",
+    name: "Media Live Output",
+    subscription: {
+      accepts: {
+        type: "multi-stream",
+        media: All
+      }
+    },
+    extraValidation: function(ctx) {
+      const audioStreams = ctx.subscriptions.filter((s) => s.streams.select.includes("audio"));
+      const videoStreams = ctx.subscriptions.filter((s) => s.streams.select.includes("video"));
+      if (audioStreams.length == 0) {
+        ctx.addWarning("Output has no audio, is this intentional");
+      }
+      if (videoStreams.length == 0) {
+        ctx.addWarning("Output has no video, is this intentional");
+      }
+    },
+    designtime: {
+      node: NodeView3
+    },
+    runtime: {
+      initialState: () => ({
+        url: void 0
+      }),
+      handleEvent: (ev, state) => {
+        const evType = ev.type;
+        switch (evType) {
+          case "url-located":
+            return { ...state, url: ev.url };
+          default:
+            assertUnreachable(evType);
+        }
+      },
+      inline: InlineView2,
+      fullscreen: FullscreenView2
+    },
+    configForm: {
+      form: {
+        channelId: {
+          help: "The channel to output to",
+          hint: {
+            type: "custom",
+            component: ChannelSelection2,
+            validation: Z.string().min(1, "Choosing a channel is mandatory")
+          }
+        },
+        inputId: {
+          help: "The input of the channel to output to",
+          hint: {
+            type: "custom",
+            component: InputSelection,
+            validation: Z.string().min(1, "Choosing an input is mandatory")
+          }
+        },
+        destinationIndex: {
+          help: "The publish URL to output to",
+          hint: {
+            type: "custom",
+            defaultValue: 0,
+            component: UrlSelection2,
+            validation: Z.number().min(0, "Choosing a url is mandatory")
+          }
+        }
+      }
+    }
+  });
+}
+function assertUnreachable(_) {
+  throw new Error("Didn't expect to get here");
+}
+
+// build/processor.aws-transcribe/info.js
+var import_react14 = __toESM(require_react());
+function info_default3({ defineComponent, Av, Subtitle, validation: { LanguageTagWithCountry, LanguageTagOptionalCountry, Z } }) {
+  const TranscribeLanguageSelection2 = import_react14.default.lazy(async () => Promise.resolve().then(() => (init_transcribe_language_selection(), transcribe_language_selection_exports)));
+  const TranslateLanguageSelection2 = import_react14.default.lazy(async () => Promise.resolve().then(() => (init_translate_language_selection(), translate_language_selection_exports)));
+  return defineComponent({
+    identifier: "processor.aws-transcribe",
+    category: "processor",
+    name: "AWS Transcribe",
+    subscription: {
+      // Must have video AND audio?
+      // Or is video optional?
+      // either way, we only want one of each
+      // and we want QUCV to respect our choice
+      accepts: {
+        type: "single-stream",
+        media: Av
+        // video because we'll use the id of it..
+      },
+      produces: {
+        type: "fixed-list",
+        possibleMedia: Subtitle,
+        keys: (cfg) => [{
+          key: "subs",
+          display: "Subtitle",
+          media: Subtitle
+        }].concat(cfg.targetLanguage ? [{
+          key: "subs-translated",
+          display: "Translated Subtitle",
+          media: Subtitle
+        }] : []),
+        selector: (selection, metadata) => metadata.filter((x) => selection.includes(x.streamKey.renditionName)).map((x) => x.streamKey)
+      }
+    },
+    extraValidation: function(ctx) {
+      const video = ctx.videoInputs();
+      const audio = ctx.audioInputs();
+      if (video.length !== 1) {
+        ctx.addError("AWS Transcribe requires a single video stream to use as a reference");
+      }
+      if (audio.length !== 1) {
+        ctx.addError("AWS Transcribe requires a single audio stream to transcribe");
+      }
+    },
+    display: (_desc) => {
+      const result = {};
+      return result;
+    },
+    configForm: {
+      form: {
+        language: { help: "Source language to transcribe", hint: { type: "custom", component: TranscribeLanguageSelection2, defaultValue: "en-US", validation: LanguageTagWithCountry } },
+        targetLanguage: { help: "Target language to translate to (optional).", hint: { type: "custom", component: TranslateLanguageSelection2, defaultValue: "", validation: Z.union([LanguageTagOptionalCountry, Z.string().length(0)]) } }
+      }
+    }
+  });
+}
+
+// build/info.js
+var InitialisedComponents = {};
+var initialised = false;
+var AllComponents = [];
+function getNodeInfo(r, type) {
+  if (!initialised) {
+    AllComponents.forEach((f) => {
+      const i = f(r);
+      InitialisedComponents[i.identifier] = i;
+    });
+    initialised = true;
+  }
+  return InitialisedComponents[type];
+}
+AllComponents.push((r) => info_default(r));
+AllComponents.push((r) => info_default2(r));
+AllComponents.push((r) => info_default3(r));
+export {
+  getNodeInfo as default
+};