create-mendix-widget-gleam 2.0.14 → 2.0.15

package/tui/build/dev/javascript/gleam_erlang/gleam@erlang@reference.erl

@@ -0,0 +1,21 @@
+-module(gleam@erlang@reference).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/erlang/reference.gleam").
+-export([new/0]).
+-export_type([reference_/0]).
+
+-if(?OTP_RELEASE >= 27).
+-define(MODULEDOC(Str), -moduledoc(Str)).
+-define(DOC(Str), -doc(Str)).
+-else.
+-define(MODULEDOC(Str), -compile([])).
+-define(DOC(Str), -compile([])).
+-endif.
+
+-type reference_() :: any().
+
+-file("src/gleam/erlang/reference.gleam", 15).
+?DOC(" Create a new unique reference.\n").
+-spec new() -> reference_().
+new() ->
+    erlang:make_ref().

package/tui/build/dev/javascript/gleam_erlang/gleam_erlang_ffi.erl

@@ -0,0 +1,164 @@
+-module(gleam_erlang_ffi).
+-export([
+    atom_from_string/1, sleep/1, sleep_forever/0, demonitor/1, new_selector/0,
+    link/1, insert_selector_handler/3, remove_selector_handler/2, select/1,
+    select/2, trap_exits/1, map_selector/2, merge_selector/2, flush_messages/0,
+    priv_directory/1, connect_node/1, register_process/2, unregister_process/1,
+    process_named/1, identity/1, 'receive'/1, 'receive'/2, new_name/1,
+    cast_down_message/1, cast_exit_reason/1
+]).
+
+-spec atom_from_string(binary()) -> {ok, atom()} | {error, nil}.
+atom_from_string(S) ->
+    try {ok, binary_to_existing_atom(S)}
+    catch error:badarg -> {error, nil}
+    end.
+
+new_name(Prefix) ->
+    Suffix = integer_to_binary(erlang:unique_integer([positive])),
+    Name = <<Prefix/bits, "$"/utf8, Suffix/bits>>,
+    binary_to_atom(Name).
+
+sleep(Microseconds) ->
+    timer:sleep(Microseconds),
+    nil.
+
+sleep_forever() ->
+    timer:sleep(infinity),
+    nil.
+
+new_selector() ->
+    {selector, #{}}.
+
+map_selector({selector, Handlers}, Fn) ->
+    MappedHandlers = maps:map(fun(_Tag, Handler) ->
+        fun(Message) -> Fn(Handler(Message)) end
+    end, Handlers),
+    {selector, MappedHandlers}.
+
+merge_selector({selector, HandlersA}, {selector, HandlersB}) ->
+    {selector, maps:merge(HandlersA, HandlersB)}.
+
+insert_selector_handler({selector, Handlers}, Tag, Fn) ->
+    {selector, Handlers#{Tag => Fn}}.
+
+remove_selector_handler({selector, Handlers}, Tag) ->
+    {selector, maps:remove(Tag, Handlers)}.
+
+select(Selector) ->
+    {ok, Message} = select(Selector, infinity),
+    Message.
+
+select({selector, Handlers}, Timeout) ->
+    AnythingHandler = maps:get(anything, Handlers, undefined),
+    receive
+        % Monitored process down messages.
+        % This is special cased so we can selectively receive based on the
+        % reference as well as the record tag.
+        {'DOWN', Ref, _, _, _} = Message when is_map_key(Ref, Handlers) ->
+            Fn = maps:get(Ref, Handlers),
+            {ok, Fn(cast_down_message(Message))};
+
+        Msg when is_map_key({element(1, Msg), tuple_size(Msg)}, Handlers) ->
+            Fn = maps:get({element(1, Msg), tuple_size(Msg)}, Handlers),
+            {ok, Fn(Msg)};
+
+        Msg when AnythingHandler =/= undefined ->
+            {ok, AnythingHandler(Msg)}
+    after Timeout ->
+        {error, nil}
+    end.
+
+cast_exit_reason(normal) -> normal;
+cast_exit_reason(killed) -> killed;
+cast_exit_reason(Other) -> {abnormal, Other}.
+
+cast_down_message({'DOWN', Ref, process, Pid, Reason}) ->
+    {process_down, Ref, Pid, cast_exit_reason(Reason)};
+cast_down_message({'DOWN', Ref, port, Pid, Reason}) ->
+    {port_down, Ref, Pid, cast_exit_reason(Reason)}.
+    
+
+'receive'({subject, _Pid, Ref}) ->
+    receive
+        {Ref, Message} -> Message
+    end;
+'receive'({named_subject, Name}) ->
+    receive
+        {Name, Message} -> Message
+    end.
+
+'receive'({subject, _Pid, Ref}, Timeout) ->
+    receive
+        {Ref, Message} -> {ok, Message}
+    after Timeout ->
+        {error, nil}
+    end;
+'receive'({named_subject, Name}, Timeout) ->
+    receive
+        {Name, Message} -> {ok, Message}
+    after Timeout ->
+        {error, nil}
+    end.
+
+demonitor(Reference) ->
+    erlang:demonitor(Reference, [flush]).
+
+link(Pid) ->
+    try
+        erlang:link(Pid)
+    catch
+        error:_ -> false
+    end.
+
+trap_exits(ShouldTrap) ->
+    erlang:process_flag(trap_exit, ShouldTrap),
+    nil.
+
+flush_messages() ->
+    receive _Message -> flush_messages()
+    after 0 -> nil
+    end.
+
+priv_directory(Name) ->
+    try erlang:binary_to_existing_atom(Name) of
+        Atom ->
+            case code:priv_dir(Atom) of
+                {error, _} -> {error, nil};
+                Path -> {ok, unicode:characters_to_binary(Path)}
+            end
+    catch
+        error:badarg -> {error, nil}
+    end.
+
+connect_node(Node) ->
+    case net_kernel:connect_node(Node) of
+        true -> {ok, Node};
+        false -> {error, failed_to_connect};
+        ignored -> {error, local_node_is_not_alive}
+    end.
+
+register_process(Pid, Name) ->
+    try
+        true = erlang:register(Name, Pid),
+        {ok, nil}
+    catch
+        error:badarg -> {error, nil}
+    end.
+
+unregister_process(Name) ->
+    try
+        true = erlang:unregister(Name),
+        {ok, nil}
+    catch
+        error:badarg -> {error, nil}
+    end.
+
+process_named(Name) ->
+    case erlang:whereis(Name) of
+        Pid when is_pid(Pid) -> {ok, Pid};
+        _ -> {error, nil}
+    end.
+
+identity(X) ->
+    X.

package/tui/build/dev/javascript/gleam_javascript/gleam/javascript/array.mjs

@@ -0,0 +1,24 @@
+import { toList, prepend as listPrepend } from "../../gleam.mjs";
+import {
+  toArray as from_list,
+  length as size,
+  map,
+  reduce as fold,
+  reduceRight as fold_right,
+  index as get,
+} from "../../gleam_javascript_ffi.mjs";
+
+export { fold, fold_right, from_list, get, map, size };
+
+/**
+ * Convert a JavaScript array to a Gleam list.
+ *
+ * Runs in linear time.
+ */
+export function to_list(items) {
+  return fold_right(
+    items,
+    toList([]),
+    (list, item) => { return listPrepend(item, list); },
+  );
+}

package/tui/build/dev/javascript/gleam_javascript/gleam/javascript/promise.mjs

@@ -0,0 +1,105 @@
+import * as $dynamic from "../../../gleam_stdlib/gleam/dynamic.mjs";
+import { Ok, Error } from "../../gleam.mjs";
+import * as $array from "../../gleam/javascript/array.mjs";
+import {
+  newPromise as new$,
+  start_promise as start,
+  resolve,
+  rescue,
+  then_await as await$,
+  map_promise as map,
+  all_promises as await_array,
+  all_promises as do_await_list,
+  race_promises as race_list,
+  race_promises as race_array,
+  wait,
+} from "../../gleam_javascript_ffi.mjs";
+
+export {
+  await$,
+  await_array,
+  map,
+  new$,
+  race_array,
+  race_list,
+  rescue,
+  resolve,
+  start,
+  wait,
+};
+
+/**
+ * Run a function on the value a promise resolves to, after it has resolved.
+ * The value returned is discarded.
+ */
+export function tap(promise, callback) {
+  let _pipe = promise;
+  return map(
+    _pipe,
+    (a) => {
+      callback(a);
+      return a;
+    },
+  );
+}
+
+/**
+ * Run a function on the value a promise resolves to, after it has resolved.
+ *
+ * The function is only called if the value is `Ok`, and the returned becomes
+ * the new value contained by the promise.
+ *
+ * This is a convenience functin that combines the `map` function with `result.try`.
+ */
+export function map_try(promise, callback) {
+  let _pipe = promise;
+  return map(
+    _pipe,
+    (result) => {
+      if (result instanceof Ok) {
+        let a = result[0];
+        return callback(a);
+      } else {
+        return result;
+      }
+    },
+  );
+}
+
+/**
+ * Run a promise returning function on the value a promise resolves to, after
+ * it has resolved.
+ *
+ * The function is only called if the value is `Ok`, and the returned becomes
+ * the new value contained by the promise.
+ *
+ * This is a convenience functin that combines the `await` function with
+ * `result.try`.
+ */
+export function try_await(promise, callback) {
+  let _pipe = promise;
+  return await$(
+    _pipe,
+    (result) => {
+      if (result instanceof Ok) {
+        let a = result[0];
+        return callback(a);
+      } else {
+        let e = result[0];
+        return resolve(new Error(e));
+      }
+    },
+  );
+}
+
+/**
+ * Chain an asynchronous operation onto an list of promises, so it runs after the
+ * promises have resolved.
+ *
+ * This is the equivilent of the `Promise.all` JavaScript static method.
+ */
+export function await_list(xs) {
+  let _pipe = xs;
+  let _pipe$1 = do_await_list(_pipe);
+  return map(_pipe$1, $array.to_list);
+}

package/tui/build/dev/javascript/gleam_javascript/gleam/javascript/symbol.mjs

@@ -0,0 +1,7 @@
+import {
+  new_symbol as new$,
+  get_symbol as get_or_create_global,
+  symbol_description as description,
+} from "../../gleam_javascript_ffi.mjs";
+
+export { description, get_or_create_global, new$ };

package/tui/build/dev/javascript/gleam_javascript/gleam.mjs

@@ -0,0 +1 @@
+export * from "../prelude.mjs";

package/tui/build/dev/javascript/gleam_javascript/gleam_javascript_ffi.mjs

@@ -0,0 +1,133 @@
+import { Ok, Error } from "./gleam.mjs";
+export function toArray(list) {
+  return list.toArray();
+}
+
+export function map(thing, fn) {
+  return thing.map(fn);
+}
+
+export function length(thing) {
+  return thing.length;
+}
+
+export function reduce(thing, acc, fn) {
+  return thing.reduce(fn, acc);
+}
+
+export function reduceRight(thing, acc, fn) {
+  return thing.reduceRight(fn, acc);
+}
+
+export function index(thing, index) {
+  return index in thing ? new Ok(thing[index]) : new Error(undefined);
+}
+
+export function object_from_entries(entries) {
+  return Object.fromEntries(entries);
+}
+
+export function new_symbol(name) {
+  return Symbol(name);
+}
+export function get_symbol(name) {
+  return Symbol.for(name);
+}
+export function symbol_description(symbol) {
+  const description = symbol.description;
+  if (symbol.description === undefined) return new Error(undefined);
+  return new Ok(description);
+}
+
+// A wrapper around a promise to prevent `Promise<Promise<T>>` collapsing into
+// `Promise<T>`.
+class PromiseLayer {
+  constructor(promise) {
+    this.promise = promise;
+  }
+
+  static wrap(value) {
+    return value instanceof Promise ? new PromiseLayer(value) : value;
+  }
+
+  static unwrap(value) {
+    return value instanceof PromiseLayer ? value.promise : value;
+  }
+}
+
+export function newPromise(executor) {
+  return new Promise((resolve) =>
+    executor((value) => {
+      resolve(PromiseLayer.wrap(value));
+    }),
+  );
+}
+
+export function start_promise() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = (value) => {
+      r(PromiseLayer.wrap(value));
+    };
+  });
+  return [promise, resolve];
+}
+
+export function resolve(value) {
+  return Promise.resolve(PromiseLayer.wrap(value));
+}
+
+export function then_await(promise, fn) {
+  return promise.then((value) => fn(PromiseLayer.unwrap(value)));
+}
+
+export function map_promise(promise, fn) {
+  return promise.then((value) =>
+    PromiseLayer.wrap(fn(PromiseLayer.unwrap(value))),
+  );
+}
+
+export function rescue(promise, fn) {
+  return promise.catch((error) => fn(error));
+}
+
+export function wait(delay) {
+  return new Promise((resolve) => {
+    globalThis.setTimeout(resolve, delay);
+  });
+}
+
+export function all_promises(...promises) {
+  if (promises.length === 1) {
+    return Promise.all(promises[0]);
+  } else {
+    return Promise.all(promises);
+  }
+}
+
+export function race_promises(...promises) {
+  if (promises.length === 1) {
+    return Promise.race(promises[0]);
+  } else {
+    return Promise.race(promises);
+  }
+}
+
+export function map_new() {
+  return new Map();
+}
+
+export function map_set(map, key, value) {
+  return map.set(key, value);
+}
+
+export function map_get(map, key) {
+  if (map.has(key)) {
+    return new Ok(map.get(key));
+  }
+  return new Error(undefined);
+}
+
+export function map_size(map) {
+  return map.size;
+}