create-mendix-widget-gleam 2.0.13 → 2.0.15

package/tui/build/dev/javascript/gleam_erlang/gleam/erlang/process.mjs

@@ -0,0 +1,161 @@
+import * as $dynamic from "../../../gleam_stdlib/gleam/dynamic.mjs";
+import * as $decode from "../../../gleam_stdlib/gleam/dynamic/decode.mjs";
+import * as $string from "../../../gleam_stdlib/gleam/string.mjs";
+import { Ok, Error, CustomType as $CustomType } from "../../gleam.mjs";
+import * as $atom from "../../gleam/erlang/atom.mjs";
+import * as $port from "../../gleam/erlang/port.mjs";
+import * as $reference from "../../gleam/erlang/reference.mjs";
+
+class Subject extends $CustomType {
+  constructor(owner, tag) {
+    super();
+    this.owner = owner;
+    this.tag = tag;
+  }
+}
+
+class NamedSubject extends $CustomType {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+}
+
+export class ExitMessage extends $CustomType {
+  constructor(pid, reason) {
+    super();
+    this.pid = pid;
+    this.reason = reason;
+  }
+}
+export const ExitMessage$ExitMessage = (pid, reason) =>
+  new ExitMessage(pid, reason);
+export const ExitMessage$isExitMessage = (value) =>
+  value instanceof ExitMessage;
+export const ExitMessage$ExitMessage$pid = (value) => value.pid;
+export const ExitMessage$ExitMessage$0 = (value) => value.pid;
+export const ExitMessage$ExitMessage$reason = (value) => value.reason;
+export const ExitMessage$ExitMessage$1 = (value) => value.reason;
+
+export class Normal extends $CustomType {}
+export const ExitReason$Normal = () => new Normal();
+export const ExitReason$isNormal = (value) => value instanceof Normal;
+
+export class Killed extends $CustomType {}
+export const ExitReason$Killed = () => new Killed();
+export const ExitReason$isKilled = (value) => value instanceof Killed;
+
+export class Abnormal extends $CustomType {
+  constructor(reason) {
+    super();
+    this.reason = reason;
+  }
+}
+export const ExitReason$Abnormal = (reason) => new Abnormal(reason);
+export const ExitReason$isAbnormal = (value) => value instanceof Abnormal;
+export const ExitReason$Abnormal$reason = (value) => value.reason;
+export const ExitReason$Abnormal$0 = (value) => value.reason;
+
+class Anything extends $CustomType {}
+
+class Process extends $CustomType {}
+
+export class ProcessDown extends $CustomType {
+  constructor(monitor, pid, reason) {
+    super();
+    this.monitor = monitor;
+    this.pid = pid;
+    this.reason = reason;
+  }
+}
+export const Down$ProcessDown = (monitor, pid, reason) =>
+  new ProcessDown(monitor, pid, reason);
+export const Down$isProcessDown = (value) => value instanceof ProcessDown;
+export const Down$ProcessDown$monitor = (value) => value.monitor;
+export const Down$ProcessDown$0 = (value) => value.monitor;
+export const Down$ProcessDown$pid = (value) => value.pid;
+export const Down$ProcessDown$1 = (value) => value.pid;
+export const Down$ProcessDown$reason = (value) => value.reason;
+export const Down$ProcessDown$2 = (value) => value.reason;
+
+export class PortDown extends $CustomType {
+  constructor(monitor, port, reason) {
+    super();
+    this.monitor = monitor;
+    this.port = port;
+    this.reason = reason;
+  }
+}
+export const Down$PortDown = (monitor, port, reason) =>
+  new PortDown(monitor, port, reason);
+export const Down$isPortDown = (value) => value instanceof PortDown;
+export const Down$PortDown$monitor = (value) => value.monitor;
+export const Down$PortDown$0 = (value) => value.monitor;
+export const Down$PortDown$port = (value) => value.port;
+export const Down$PortDown$1 = (value) => value.port;
+export const Down$PortDown$reason = (value) => value.reason;
+export const Down$PortDown$2 = (value) => value.reason;
+
+export const Down$monitor = (value) => value.monitor;
+export const Down$reason = (value) => value.reason;
+
+export class TimerNotFound extends $CustomType {}
+export const Cancelled$TimerNotFound = () => new TimerNotFound();
+export const Cancelled$isTimerNotFound = (value) =>
+  value instanceof TimerNotFound;
+
+/**
+ * The timer was found and cancelled before it triggered.
+ *
+ * The amount of remaining time before the timer was due to be triggered is
+ * returned in milliseconds.
+ */
+export class Cancelled extends $CustomType {
+  constructor(time_remaining) {
+    super();
+    this.time_remaining = time_remaining;
+  }
+}
+export const Cancelled$Cancelled = (time_remaining) =>
+  new Cancelled(time_remaining);
+export const Cancelled$isCancelled = (value) => value instanceof Cancelled;
+export const Cancelled$Cancelled$time_remaining = (value) =>
+  value.time_remaining;
+export const Cancelled$Cancelled$0 = (value) => value.time_remaining;
+
+class Kill extends $CustomType {}
+
+/**
+ * Create a subject for the given process with the give tag. This is unsafe!
+ * There's nothing here that verifies that the message the subject receives is
+ * expected and that the tag is not already in use.
+ *
+ * You should almost certainly not use this function.
+ * 
+ * @ignore
+ */
+export function unsafely_create_subject(owner, tag) {
+  return new Subject(owner, tag);
+}
+
+/**
+ * Create a subject for a name, which can be used to send and receive messages.
+ *
+ * All subjects created for the same name behave identically and can be used
+ * interchangably.
+ */
+export function named_subject(name) {
+  return new NamedSubject(name);
+}
+
+/**
+ * Get the name of a subject, returning an error if it doesn't have one.
+ */
+export function subject_name(subject) {
+  if (subject instanceof Subject) {
+    return new Error(undefined);
+  } else {
+    let name = subject.name;
+    return new Ok(name);
+  }
+}

package/tui/build/dev/javascript/gleam_erlang/gleam/erlang/reference.mjs

@@ -0,0 +1 @@
+export {}

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

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

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

@@ -0,0 +1,43 @@
+-module(gleam@erlang@application).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/erlang/application.gleam").
+-export([priv_directory/1]).
+-export_type([start_type/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.
+
+?MODULEDOC(
+    " An Erlang application is a collection of code that can be loaded into the\n"
+    " Erlang virtual machine and even started and stopped if they define a\n"
+    " start module and supervision tree. Each Gleam package is an Erlang\n"
+    " application.\n"
+).
+
+-type start_type() :: normal |
+    {takeover, gleam@erlang@node:node_()} |
+    {failover, gleam@erlang@node:node_()}.
+
+-file("src/gleam/erlang/application.gleam", 37).
+?DOC(
+    " Returns the path of an application's `priv` directory, where extra non-Gleam\n"
+    " or Erlang files are typically kept. Each Gleam package is an Erlang\n"
+    " application.\n"
+    "\n"
+    " Returns an error if no application was found with the given name.\n"
+    "\n"
+    " # Example\n"
+    "\n"
+    " ```gleam\n"
+    " application.priv_directory(\"my_app\")\n"
+    " // -> Ok(\"/some/location/my_app/priv\")\n"
+    " ```\n"
+).
+-spec priv_directory(binary()) -> {ok, binary()} | {error, nil}.
+priv_directory(Name) ->
+    gleam_erlang_ffi:priv_directory(Name).

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

@@ -0,0 +1,94 @@
+-module(gleam@erlang@atom).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/erlang/atom.gleam").
+-export([get/1, create/1, to_string/1, to_dynamic/1, cast_from_dynamic/1, decoder/0]).
+-export_type([atom_/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 atom_() :: any().
+
+-file("src/gleam/erlang/atom.gleam", 27).
+?DOC(
+    " Finds an existing atom for the given string.\n"
+    "\n"
+    " If no atom is found in the virtual machine's atom table for the string then\n"
+    " an error is returned.\n"
+).
+-spec get(binary()) -> {ok, atom_()} | {error, nil}.
+get(A) ->
+    gleam_erlang_ffi:atom_from_string(A).
+
+-file("src/gleam/erlang/atom.gleam", 39).
+?DOC(
+    " Creates an atom from a string, inserting a new value into the virtual\n"
+    " machine's atom table if an atom does not already exist for the given\n"
+    " string.\n"
+    "\n"
+    " We must be careful when using this function as there is a limit to the\n"
+    " number of atom that can fit in the virtual machine's atom table. Never\n"
+    " convert user input into atoms as filling the atom table will cause the\n"
+    " virtual machine to crash!\n"
+).
+-spec create(binary()) -> atom_().
+create(A) ->
+    erlang:binary_to_atom(A).
+
+-file("src/gleam/erlang/atom.gleam", 52).
+?DOC(
+    " Returns a `String` corresponding to the text representation of the given\n"
+    " `Atom`.\n"
+    "\n"
+    " ## Examples\n"
+    " ```gleam\n"
+    " let ok_atom = create(\"ok\")\n"
+    " to_string(ok_atom)\n"
+    " // -> \"ok\"\n"
+    " ```\n"
+).
+-spec to_string(atom_()) -> binary().
+to_string(A) ->
+    erlang:atom_to_binary(A).
+
+-file("src/gleam/erlang/atom.gleam", 59).
+?DOC(
+    " Convert an atom to a dynamic value, throwing away the type information. \n"
+    "\n"
+    " This may be useful for testing decoders.\n"
+).
+-spec to_dynamic(atom_()) -> gleam@dynamic:dynamic_().
+to_dynamic(A) ->
+    gleam_erlang_ffi:identity(A).
+
+-file("src/gleam/erlang/atom.gleam", 62).
+-spec cast_from_dynamic(gleam@dynamic:dynamic_()) -> atom_().
+cast_from_dynamic(A) ->
+    gleam_erlang_ffi:identity(A).
+
+-file("src/gleam/erlang/atom.gleam", 71).
+?DOC(
+    " A dynamic decoder for atoms.\n"
+    "\n"
+    " You almost certainly should not use this to work with externally defined\n"
+    " functions. They return known types, so you should define the external\n"
+    " functions with the correct types, defining wrapper functions in Erlang if\n"
+    " the external types cannot be mapped directly onto Gleam types.\n"
+).
+-spec decoder() -> gleam@dynamic@decode:decoder(atom_()).
+decoder() ->
+    gleam@dynamic@decode:new_primitive_decoder(
+        <<"Atom"/utf8>>,
+        fun(Data) -> case erlang:is_atom(Data) of
+                true ->
+                    {ok, gleam_erlang_ffi:identity(Data)};
+
+                false ->
+                    {error, erlang:binary_to_atom(<<"nil"/utf8>>)}
+            end end
+    ).

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

@@ -0,0 +1,42 @@
+-module(gleam@erlang@charlist).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/erlang/charlist.gleam").
+-export([to_string/1, from_string/1]).
+-export_type([charlist/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.
+
+?MODULEDOC(
+    " A charlist is a list of integers where all the integers are valid code\n"
+    " points.\n"
+    "\n"
+    " In practice, you will not come across them often, except perhaps when\n"
+    " interfacing with Erlang, in particular when using older libraries that do\n"
+    " not accept binaries as arguments.\n"
+).
+
+-type charlist() :: any().
+
+-file("src/gleam/erlang/charlist.gleam", 18).
+?DOC(
+    " Convert a charlist to a string using Erlang's\n"
+    " `unicode:characters_to_binary`.\n"
+).
+-spec to_string(charlist()) -> binary().
+to_string(A) ->
+    unicode:characters_to_binary(A).
+
+-file("src/gleam/erlang/charlist.gleam", 24).
+?DOC(
+    " Convert a string to a charlist using Erlang's\n"
+    " `unicode:characters_to_list`.\n"
+).
+-spec from_string(binary()) -> charlist().
+from_string(A) ->
+    unicode:characters_to_list(A).

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

@@ -0,0 +1,80 @@
+-module(gleam@erlang@node).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/erlang/node.gleam").
+-export([self/0, visible/0, connect/1, name/1]).
+-export_type([node_/0, connect_error/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.
+
+?MODULEDOC(
+    " Multiple Erlang VM instances can form a cluster to make a distributed\n"
+    " Erlang system, talking directly to each other using messages rather than\n"
+    " other communication protocols like HTTP. In a distributed Erlang system\n"
+    " each virtual machine is called a _node_. This module provides Node related\n"
+    " types and functions to be used as a foundation by other packages providing\n"
+    " more specialised functionality.\n"
+    "\n"
+    " For more information on distributed Erlang systems see the Erlang\n"
+    " documentation: <https://www.erlang.org/doc/system/distributed.html>.\n"
+).
+
+-type node_() :: any().
+
+-type connect_error() :: failed_to_connect | local_node_is_not_alive.
+
+-file("src/gleam/erlang/node.gleam", 18).
+?DOC(" Return the current node.\n").
+-spec self() -> node_().
+self() ->
+    erlang:node().
+
+-file("src/gleam/erlang/node.gleam", 31).
+?DOC(
+    " Return a list of all visible nodes in the cluster, not including the current\n"
+    " node.\n"
+    "\n"
+    " The current node can be included by calling `self()` and prepending the\n"
+    " result.\n"
+    "\n"
+    " ```gleam\n"
+    " let all_nodes = [node.self(), ..node.visible()]\n"
+    " ```\n"
+).
+-spec visible() -> list(node_()).
+visible() ->
+    erlang:nodes().
+
+-file("src/gleam/erlang/node.gleam", 52).
+?DOC(
+    " Establish a connection to a node, so the nodes can send messages to each\n"
+    " other and any other connected nodes.\n"
+    "\n"
+    " Returns `Error(FailedToConnect)` if the node is not reachable.\n"
+    "\n"
+    " Returns `Error(LocalNodeIsNotAlive)` if the local node is not alive, meaning\n"
+    " it is not running in distributed mode.\n"
+).
+-spec connect(gleam@erlang@atom:atom_()) -> {ok, node_()} |
+    {error, connect_error()}.
+connect(Node) ->
+    gleam_erlang_ffi:connect_node(Node).
+
+-file("src/gleam/erlang/node.gleam", 63).
+?DOC(
+    " Get the atom name of a node.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " assert name(my_node) == atom.create(\"app1@localhost\")\n"
+    " ```\n"
+).
+-spec name(node_()) -> gleam@erlang@atom:atom_().
+name(Node) ->
+    gleam_erlang_ffi:identity(Node).

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

@@ -0,0 +1,8 @@
+-module(gleam@erlang@port).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/erlang/port.gleam").
+-export_type([port_/0]).
+
+-type port_() :: any().
+
+