flowyaml 0.1.0.0__py3-none-any.whl

flowyaml/__init__.py

@@ -0,0 +1,120 @@
+"""FlowYAML: a callable Python renderer for YAML-defined process flows.
+
+Given valid FlowYAML YAML, the package produces either a complete self
+sufficient single page HTML document or a self contained embeddable fragment.
+The generated artifact renders in a browser with no Python process, no server,
+no npm build and no network access.
+
+That artifact is a snapshot: it shows the YAML as it stood when it was
+written. When the YAML is still being edited, ``data="url"`` renders the same
+page with its graph left out and fetched from a host instead, and
+``flowyaml.serve`` is a stdlib host that re-reads the file per request. See
+``docs/live_updates.md``.
+
+v0 is a renderer, not an editor.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._version import __version__
+from .api import (
+    load,
+    models,
+    payload,
+    payload_json,
+    read_bpmn,
+    read_mermaid,
+    read_source,
+    render,
+    render_file,
+    to_yaml,
+    validate,
+    write_html,
+)
+from .errors import (
+    FlowYAMLError,
+    FlowYAMLImportError,
+    FlowYAMLModelError,
+    FlowYAMLOptionError,
+    FlowYAMLValidationError,
+    ValidationIssue,
+)
+from .model import (
+    CLICKABLE_NODE_TYPES,
+    EDGE_KINDS,
+    EDGE_STYLES,
+    NODE_TYPES,
+    Diagram,
+    Edge,
+    Model,
+    Node,
+)
+from .renderer import (
+    ASSET_MODES,
+    DATA_MODES,
+    DEFAULT_POLL_MS,
+    LAYOUT_OPTIONS,
+    OUTPUT_MODES,
+)
+from .themes import DEFAULT_THEME, THEMES, theme_names
+
+__all__ = [
+    "__version__",
+    # public API
+    "render",
+    "render_file",
+    "write_html",
+    "validate",
+    "load",
+    "models",
+    "payload",
+    "payload_json",
+    "read_source",
+    "to_yaml",
+    # live host (imported on first use)
+    "serve",
+    "create_server",
+    "LinkedSource",
+    # importers
+    "read_mermaid",
+    "read_bpmn",
+    # errors
+    "ValidationIssue",
+    "FlowYAMLError",
+    "FlowYAMLValidationError",
+    "FlowYAMLModelError",
+    "FlowYAMLOptionError",
+    "FlowYAMLImportError",
+    # model
+    "Diagram",
+    "Model",
+    "Node",
+    "Edge",
+    "NODE_TYPES",
+    "EDGE_KINDS",
+    "EDGE_STYLES",
+    "CLICKABLE_NODE_TYPES",
+    # options
+    "OUTPUT_MODES",
+    "ASSET_MODES",
+    "DATA_MODES",
+    "DEFAULT_POLL_MS",
+    "LAYOUT_OPTIONS",
+    "DEFAULT_THEME",
+    "THEMES",
+    "theme_names",
+]
+
+#: The live host is the one part of the package that needs a socket. Importing
+#: it on demand keeps ``import flowyaml`` a pure renderer import.
+_LIVE_EXPORTS = frozenset({"serve", "create_server", "LinkedSource"})
+
+
+def __getattr__(name: str) -> Any:
+    if name in _LIVE_EXPORTS:
+        from . import live
+
+        return getattr(live, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

flowyaml/__main__.py

@@ -0,0 +1,10 @@
+"""Allow ``python -m flowyaml``."""
+
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

flowyaml/_version.py

@@ -0,0 +1,3 @@
+"""Single source of truth for the FlowYAML distribution version."""
+
+__version__ = "0.1.0.0"

flowyaml/api.py

@@ -0,0 +1,229 @@
+"""The FlowYAML v0 public API."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from .errors import FlowYAMLValidationError, ValidationIssue
+from .importers import read_bpmn, read_mermaid
+from .model import Diagram
+from .renderer import DEFAULT_POLL_MS, data_payload, render_diagram
+from .serialize import to_yaml as _diagram_to_yaml
+from .themes import DEFAULT_THEME
+from .validation import build
+
+__all__ = [
+    "render",
+    "render_file",
+    "write_html",
+    "validate",
+    "load",
+    "models",
+    "payload",
+    "payload_json",
+    "read_source",
+    "read_mermaid",
+    "read_bpmn",
+    "to_yaml",
+]
+
+_YAML_SUFFIXES = (".yaml", ".yml", ".flowyaml")
+
+
+def read_source(source: str | os.PathLike[str]) -> str:
+    """Return YAML text for ``source``.
+
+    A :class:`~pathlib.Path` is always read from disk. A ``str`` is treated as
+    YAML text unless it is a single line with a YAML suffix that exists on
+    disk, which keeps ``write_html("flow.yaml", ...)`` convenient without ever
+    guessing about real YAML content.
+    """
+    if isinstance(source, Path) or (
+        isinstance(source, os.PathLike) and not isinstance(source, str)
+    ):
+        return Path(source).read_text(encoding="utf-8")
+    if isinstance(source, str):
+        looks_like_path = (
+            "\n" not in source
+            and len(source) < 4096
+            and source.strip().lower().endswith(_YAML_SUFFIXES)
+        )
+        if looks_like_path:
+            candidate = Path(source)
+            try:
+                if candidate.is_file():
+                    return candidate.read_text(encoding="utf-8")
+            except OSError:  # pragma: no cover - unusual filesystem states
+                pass
+        return source
+    raise TypeError(f"source must be str or PathLike, not {type(source).__name__}")
+
+
+def validate(source: str | os.PathLike[str] | Diagram) -> tuple[ValidationIssue, ...]:
+    """Return every structured issue found in ``source``.
+
+    An empty tuple means the source is renderable. A :class:`Diagram` is
+    already normalized, so it reports nothing.
+    """
+    if isinstance(source, Diagram):
+        return ()
+    return build(read_source(source))[1]
+
+
+def load(source: str | os.PathLike[str] | Diagram) -> Diagram:
+    """Parse and validate ``source`` into the immutable graph model.
+
+    A :class:`Diagram` passes straight through, which is what lets an
+    importer's result be handed to :func:`render` and :func:`write_html`
+    without a YAML round trip.
+    """
+    if isinstance(source, Diagram):
+        return source
+    diagram, issues = build(read_source(source))
+    if issues or diagram is None:
+        raise FlowYAMLValidationError(issues)
+    return diagram
+
+
+def models(source: str | os.PathLike[str] | Diagram) -> tuple[str, ...]:
+    """Return the ``meta.id`` of every model in ``source``, in document order."""
+    return load(source).model_ids
+
+
+def to_yaml(source: str | os.PathLike[str] | Diagram) -> str:
+    """Return canonical FlowYAML YAML for ``source``.
+
+    Given an imported diagram this is the round trip back to editable source
+    text, so a Mermaid or BPMN file can become a FlowYAML file on disk. The
+    output never carries geometry: FlowYAML lays a graph out in the browser.
+    """
+    return _diagram_to_yaml(load(source))
+
+
+def payload(
+    source: str | os.PathLike[str] | Diagram,
+    *,
+    model_id: str | None = None,
+    revision: str | None = None,
+) -> dict[str, Any]:
+    """Return the JSON body a host serves to a ``data="url"`` page.
+
+    This is the FlowYAML counterpart of the ERP DINFRA ``data.json`` view: the
+    host re-reads the YAML file, calls this, and answers with the result, so a
+    saved edit is visible on the next request. ``revision`` is any opaque
+    marker that changes when the source does - a content digest, an mtime, a
+    commit id. The page polls for it and reloads the graph when it moves.
+    """
+    return data_payload(load(source), model_id=model_id, revision=revision)
+
+
+def payload_json(
+    source: str | os.PathLike[str] | Diagram,
+    *,
+    model_id: str | None = None,
+    revision: str | None = None,
+) -> str:
+    """Return :func:`payload` serialized as compact UTF-8-safe JSON."""
+    return json.dumps(
+        payload(source, model_id=model_id, revision=revision),
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+
+
+def render(
+    source: str | os.PathLike[str] | Diagram,
+    *,
+    model_id: str | None = None,
+    output: str = "document",
+    assets: str = "inline",
+    data: str = "inline",
+    data_url: str | None = None,
+    revision_url: str | None = None,
+    poll_ms: int = DEFAULT_POLL_MS,
+    theme: str = DEFAULT_THEME,
+    instance_id: str | None = None,
+) -> str:
+    """Render ``source`` to self-sufficient HTML.
+
+    Parameters
+    ----------
+    source:
+        YAML text, a path to a YAML file, or a :class:`Diagram` such as the
+        one :func:`read_mermaid` and :func:`read_bpmn` return.
+    model_id:
+        Which embedded model opens first. Defaults to the first document.
+        Every model stays embedded regardless, so subprocess navigation works.
+    output:
+        ``"document"`` for a complete page, ``"fragment"`` for a host-safe
+        block that can be mounted more than once on one page.
+    assets:
+        ``"inline"`` only in v0.
+    data:
+        ``"inline"`` embeds the graph once; the artifact is then complete and
+        offline, and it never sees a later edit of the YAML. ``"url"`` leaves
+        the graph out and has the page fetch it from ``data_url``, so an edited
+        YAML file reaches the page on reload, and within ``poll_ms`` without
+        one. A ``"url"`` page needs an http host: browsers refuse the fetch
+        when the page itself was opened over ``file://``.
+    data_url:
+        Where the host serves :func:`payload`. Required for ``data="url"``,
+        rejected otherwise. Relative, or absolute http(s).
+    revision_url:
+        Optional cheaper poll target answering ``{"revision": ...}``. Without
+        it the page polls ``data_url`` itself and compares revisions.
+    poll_ms:
+        How often a ``"url"`` page checks for a new revision. ``0`` polls
+        never, which is the ERP DINFRA behaviour: an edit shows up on reload.
+    theme:
+        Registered theme name. Defaults to ``dornelles_multitech``.
+    instance_id:
+        Fixed DOM prefix. Omit it for a fresh random prefix per render, which
+        is what keeps two fragments on one page from colliding.
+
+    Raises
+    ------
+    FlowYAMLValidationError
+        If the source has any validation issue.
+    FlowYAMLModelError
+        If ``model_id`` is not present in the source.
+    FlowYAMLOptionError
+        For an unsupported ``output``, ``assets``, ``theme`` or ``instance_id``.
+    """
+    diagram = load(source)
+    return render_diagram(
+        diagram,
+        model_id=model_id,
+        output=output,
+        assets=assets,
+        data=data,
+        data_url=data_url,
+        revision_url=revision_url,
+        poll_ms=poll_ms,
+        theme=theme,
+        instance_id=instance_id,
+    )
+
+
+def render_file(path: str | os.PathLike[str], **options: Any) -> str:
+    """Render the YAML file at ``path``."""
+    return render(Path(path).read_text(encoding="utf-8"), **options)
+
+
+def write_html(
+    source_or_path: str | os.PathLike[str] | Diagram,
+    destination: str | os.PathLike[str],
+    **options: Any,
+) -> Path:
+    """Render ``source_or_path`` and write it to ``destination``.
+
+    Returns the written path.
+    """
+    target = Path(destination)
+    if target.parent and not target.parent.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(render(source_or_path, **options), encoding="utf-8")
+    return target

flowyaml/assets/__init__.py

@@ -0,0 +1,5 @@
+"""Vendored browser assets for FlowYAML v0.
+
+``elk.bundled.js`` is the elkjs 0.9.3 UMD browser bundle, redistributed under
+the Eclipse Public License 2.0. See ``elk.LICENSE.md`` and ``elk.VERSION.txt``.
+"""

flowyaml/assets/elk.LICENSE.md

@@ -0,0 +1,264 @@
+# Eclipse Public License - v 2.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF
+THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+## 1. DEFINITIONS
+
+“Contribution” means:
+
+-   a\) in the case of the initial Contributor, the initial content
+    Distributed under this Agreement, and
+-   b\) in the case of each subsequent Contributor:
+    -   i\) changes to the Program, and
+    -   ii\) additions to the Program;
+
+    where such changes and/or additions to the Program originate from
+    and are Distributed by that particular Contributor. A Contribution
+    “originates” from a Contributor if it was added to the Program by
+    such Contributor itself or anyone acting on such Contributor's
+    behalf. Contributions do not include changes or additions to the
+    Program that are not Modified Works.
+
+“Contributor” means any person or entity that Distributes the Program.
+
+“Licensed Patents” mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+“Program” means the Contributions Distributed in accordance with this
+Agreement.
+
+“Recipient” means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+“Derivative Works” shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+“Modified Works” shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+“Distribute” means the acts of a) distributing or b) making available in
+any manner that enables the transfer of a copy.
+
+“Source Code” means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+“Secondary License” means either the GNU General Public License, Version
+2.0, or any later versions of that license, including any exceptions or
+additional permissions as identified by the initial Contributor.
+
+## 2. GRANT OF RIGHTS
+
+-   a\) Subject to the terms of this Agreement, each Contributor hereby
+    grants Recipient a non-exclusive, worldwide, royalty-free copyright
+    license to reproduce, prepare Derivative Works of, publicly display,
+    publicly perform, Distribute and sublicense the Contribution of such
+    Contributor, if any, and such Derivative Works.
+-   b\) Subject to the terms of this Agreement, each Contributor hereby
+    grants Recipient a non-exclusive, worldwide, royalty-free patent license
+    under Licensed Patents to make, use, sell, offer to sell, import and
+    otherwise transfer the Contribution of such Contributor, if any, in
+    Source Code or other form. This patent license shall apply to the
+    combination of the Contribution and the Program if, at the time the
+    Contribution is added by the Contributor, such addition of the
+    Contribution causes such combination to be covered by the
+    Licensed Patents. The patent license shall not apply to any other
+    combinations which include the Contribution. No hardware per se is
+    licensed hereunder.
+-   c\) Recipient understands that although each Contributor grants the
+    licenses to its Contributions set forth herein, no assurances are
+    provided by any Contributor that the Program does not infringe the
+    patent or other intellectual property rights of any other entity. Each
+    Contributor disclaims any liability to Recipient for claims brought by
+    any other entity based on infringement of intellectual property rights
+    or otherwise. As a condition to exercising the rights and licenses
+    granted hereunder, each Recipient hereby assumes sole responsibility to
+    secure any other intellectual property rights needed, if any. For
+    example, if a third party patent license is required to allow Recipient
+    to Distribute the Program, it is Recipient's responsibility to acquire
+    that license before distributing the Program.
+-   d\) Each Contributor represents that to its knowledge it has sufficient
+    copyright rights in its Contribution, if any, to grant the copyright
+    license set forth in this Agreement.
+-   e\) Notwithstanding the terms of any Secondary License, no Contributor
+    makes additional grants to any Recipient (other than those set forth in
+    this Agreement) as a result of such Recipient's receipt of the Program
+    under the terms of a Secondary License (if permitted under the terms of
+    Section 3).
+
+## 3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+-   a\) the Program must also be made available as Source Code, in accordance
+    with section 3.2, and the Contributor must accompany the Program with a
+    statement that the Source Code for the Program is available under this
+    Agreement, and informs Recipients how to obtain it in a reasonable
+    manner on or through a medium customarily used for software exchange;
+    and
+-   b\) the Contributor may Distribute the Program under a license different
+    than this Agreement, provided that such license:
+    -   i\) effectively disclaims on behalf of all other Contributors all
+        warranties and conditions, express and implied, including warranties or
+        conditions of title and non-infringement, and implied warranties or
+        conditions of merchantability and fitness for a particular purpose;
+    -   ii\) effectively excludes on behalf of all other Contributors all
+        liability for damages, including direct, indirect, special, incidental
+        and consequential damages, such as lost profits;
+    -   iii\) does not attempt to limit or alter the recipients' rights in the
+        Source Code under section 3.2; and
+    -   iv\) requires any subsequent distribution of the Program by any party to
+        be under a license that satisfies the requirements of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+-   a\) it must be made available under this Agreement, or if the Program (i)
+    is combined with other material in a separate file or files made
+    available under a Secondary License, and (ii) the initial Contributor
+    attached to the Source Code the notice described in Exhibit A of this
+    Agreement, then the Program may be made available under the terms of
+    such Secondary Licenses, and
+-   b\) a copy of this Agreement must be included with each copy of
+    the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability (‘notices’) contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+## 4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program, the
+Contributor who includes the Program in a commercial product offering
+should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in
+a commercial product offering, such Contributor (“Commercial
+Contributor”) hereby agrees to defend and indemnify every other
+Contributor (“Indemnified Contributor”) against any losses, damages and
+costs (collectively “Losses”) arising from claims, lawsuits and other
+legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the
+Program in a commercial product offering. The obligations in this
+section do not apply to any claims or Losses relating to any actual or
+alleged intellectual property infringement. In order to qualify, an
+Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial
+Contributor to control, and cooperate with the Commercial Contributor
+in, the defense and any related settlement negotiations. The Indemnified
+Contributor may participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.
+
+## 5. NO WARRANTY {#warranty}
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS”
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs or
+equipment, and unavailability or interruption of operations.
+
+## 6. DISCLAIMER OF LIABILITY {#disclaimer}
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+## 7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including
+a cross-claim or counterclaim in a lawsuit) alleging that the Program
+itself (excluding combinations of the Program with other software or
+hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails
+to comply with any of the material terms or conditions of this Agreement
+and does not cure such failure in a reasonable period of time after
+becoming aware of such noncompliance. If all Recipient's rights under
+this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's
+obligations under this Agreement and any licenses granted by Recipient
+relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and may
+only be modified in the following manner. The Agreement Steward reserves
+the right to publish new versions (including revisions) of this
+Agreement from time to time. No one other than the Agreement Steward has
+the right to modify this Agreement. The Eclipse Foundation is the
+initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is
+published, Contributor may elect to Distribute the Program (including
+its Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+## Exhibit A – Form of Secondary Licenses Notice {#exhibit-a}
+
+“This Source Code may also be made available under the following
+Secondary Licenses when the conditions for such availability set forth
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}.”
+
+> Simply including a copy of this Agreement, including this Exhibit A is
+> not sufficient to license the Source Code under Secondary Licenses.
+>
+> If it is not possible or desirable to put the notice in a particular
+> file, then You may include the notice in a location (such as a LICENSE
+> file in a relevant directory) where a recipient would be likely to
+> look for such a notice.
+>
+> You may add additional accurate notices of copyright ownership.

flowyaml/assets/elk.VERSION.txt

@@ -0,0 +1,4 @@
+elkjs 0.9.3
+https://github.com/kieler/elkjs
+Eclipse Public License 2.0
+file: lib/elk.bundled.js (UMD browser bundle)