Update Meteor to 1.2

This requires local copies of packages that are broken or not Polymer 0.5

.codio

@@ -0,0 +1,14 @@
+{
+// Configure your Run and Preview buttons here.
+
+// Run button configuration
+  "commands": {
+        "Run Meteor": "cd rpg-docs \n ROOT_URL=http://period-sheriff.codio.io:3000 meteor"
+  },
+
+// Preview button configuration
+  "preview": {
+      "Prieview": "http://period-sheriff-3000.codio.io",
+	  "Ungit": "https://period-sheriff-9501.codio.io/#/repository?path=/home/codio/workspace"
+  }
+}

.gitignore

@@ -1 +0,0 @@
-build

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,13 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="HtmlUnknownAttribute" enabled="false" level="WARNING" enabled_by_default="false">
+      <option name="myValues">
+        <value>
+          <list size="0" />
+        </value>
+      </option>
+      <option name="myCustomValuesEnabled" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,7 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="PROJECT_PROFILE" value="Project Default" />
+    <option name="USE_PROJECT_PROFILE" value="true" />
+    <version value="1.0" />
+  </settings>
+</component>

.jscsrc

@@ -0,0 +1,56 @@
+{
+	"requireOperatorBeforeLineBreak": true,
+	"requireCamelCaseOrUpperCaseIdentifiers": true,
+	"maximumLineLength": {
+		"value": 80,
+		"allowComments": true,
+		"allowRegex": true
+	},
+	"validateIndentation": "\t",
+	"validateQuoteMarks": "\"",
+
+	"disallowMultipleLineStrings": true,
+	"disallowMixedSpacesAndTabs": "smart",
+	"disallowTrailingWhitespace": true,
+	"disallowSpaceAfterPrefixUnaryOperators": true,
+	"disallowMultipleVarDecl": true,
+	"disallowNewlineBeforeBlockStatements": true,
+	"disallowKeywordsOnNewLine": ["else"],
+
+	"requireSpaceAfterKeywords": [
+		"if",
+		"else",
+		"for",
+		"while",
+		"do",
+		"switch",
+		"return",
+		"try",
+		"catch"
+	],
+	"requireSpaceBeforeBinaryOperators": [
+		"=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=",
+		"&=", "|=", "^=", "+=",
+
+		"+", "-", "*", "/", "%", "<<", ">>", ">>>", "&",
+		"|", "^", "&&", "||", "===", "==", ">=",
+		"<=", "<", ">", "!=", "!=="
+	],
+	"requireSpaceAfterBinaryOperators": true,
+	"requireSpacesInConditionalExpression": true,
+	"requireSpacesInForStatement": true,
+	"requireTrailingComma": {
+		"ignoreSingleValue": true,
+		"ignoreSingleLine": true
+	},
+	"requireLineFeedAtFileEnd": true,
+	"disallowSpacesInAnonymousFunctionExpression": {
+		"beforeOpeningRoundBrace": true
+	},
+	"disallowSpacesInsideObjectBrackets": "all",
+	"disallowSpacesInsideArrayBrackets": "all",
+	"disallowSpacesInsideParentheses": true,
+
+	"disallowMultipleLineBreaks": true,
+	"disallowNewlineBeforeBlockStatements": true
+}

.jshintrc

@@ -0,0 +1,3 @@
+{
+	"undef": false
+}

Dockerfile

@@ -1,14 +0,0 @@
-FROM ubuntu:latest
-RUN apt-get update --quiet \
-    && apt-get install --quiet --yes \
-    bsdtar \
-    curl \
-    git
-RUN ln --symbolic --force $(which bsdtar) $(which tar)
-RUN useradd --create-home --shell /bin/bash dicecloud
-USER dicecloud
-WORKDIR /home/dicecloud
-RUN curl https://install.meteor.com/?release=1.8.0.2 | sh
-ENV PATH="${PATH}:/home/dicecloud/.meteor"
-COPY dev.sh ./dev.sh
-ENTRYPOINT ./dev.sh

License.md

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    {one line to give the program's name and a brief idea of what it does.}
-    Copyright (C) {year}  {name of author}
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    {project}  Copyright (C) {year}  {fullname}
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -1,89 +1,4 @@
-DiceCloud
+RPG Docs
 ========
 
-This is the repo for [DiceCloud](dicecloud.com).
+This is the repo for [DiceCloud](dicecloud.com). The currently deployed version should always be the head of the master branch.
-
-DiceCloud is a free, auditable, real-time character sheet for D&D 5e.
-
-Philosophy
-----------
-
-Setting up your character on DiceCloud takes a little longer than
-just filling it in on a paper character sheet would. The goal of using an
-online sheet is to make actually playing the game more streamlined, and
-ultimately more fun. So putting a little extra effort into setting up a
-character now pays off over and over again once you're playing.
-
-The idea is to track where each number comes from, and allow you to easily make
-changes on the fly. Let's look at a hypothetical example.
-
-> You need to swim through a sunken section of dungeon to fetch the quest's Thing.
-> You'll need to take off your magical Plate Armor of +1 Constitution to swim
-> without sinking, of course.
->
-> Taking it off will take away that disadvantage on
-> stealth checks, change your armor class, your speed and your constitution, and
-> which in turn changes your hit points and your constitution saving throw.
-> Working out all those changes in the middle of a game will drag the game to a
-> halt.
->
-> Fortunately you have DiceCloud, so it's a matter of dragging
-> your Plate Armor +1 Con from your "equipment" box to your "backpack" box and
-> you're done. Your hitpoints change correctly, your saving throws are up to date,
-> your armor class goes back to reflecting the fact that you have natural armor
-> from being a dragonborn. Your character sheet keeps up and you
-> ultimately get more time to play the game. Huzzah!
-
-Getting started
----------------
-
-Running DiceCloud locally, either to host it yourself away from an internet
-connection, or to contribute to developing it further, is fairly
-straightforward and it should work on Linux, Windows, and Mac.
-
-You'll need to have installed:
-
-- [git](https://www.atlassian.com/git/tutorials/install-git)
-- [Meteor](https://www.meteor.com/install)
-
-Then, it's just a matter of cloning this repository into a folder, and running
-`meteor` in the app directory.
-
-`git clone https://github.com/ThaumRystra/DiceCloud dicecloud`  
-`cd dicecloud`  
-`cd app`  
-`meteor npm install`  
-`meteor`
-
-You should see this:
-
-```
-=> Started proxy.
-=> [HMR] Dev server listening on port 3003.
-=> Started MongoDB.
-=> Started your app.
-
-=> App running at: http://localhost:3000/
-```
-
-Environmental Variables
------------------------
-
-```
-MAIL_URL=smtp://<your smtp mail url>
-METEOR_SETTINGS={ "public": { "environment": "production", "patreon": { "clientId": "<your patreon client ID>", "campaignId": "<your campaign id>" } }, "patreon": { "clientSecret": "<your client secret>", "creatorAccessToken": "<your creator access token>" } }
-MONGO_OPLOG_URL=mongodb+srv://<your url for the oplog account of your mongo database>
-MONGO_URL=mongodb+srv://<your url for the read/write account of your mongo database>
-NPM_CONFIG_PRODUCTION=true
-PROJECT_DIR=app
-ROOT_URL=https://<url of your DiceCloud instance>
-DEFAULT_LIBRARIES=<comma separated list of library ids that will be subscribed by default: "abc123,def456">
-```
-
-To disable Patreon features and unlock all paid restrictions for all users of your deployment, replace
-`"patreon": { "clientId": ... }"` with `"disablePatreon": true` in the public key of the METEOR_SETTINGS environment variable.
-
-Alternatively run `meteor run --settings exampleMeteorSettings.json` to start the app with the example settings that disable Patreon by default.
-
-Now, visiting [](http://localhost:3000/) should show you an empty instance of
-DiceCloud running.

app/.gitignore

@@ -1,13 +0,0 @@
-.meteor/local
-.meteor/meteorite
-.demeteorized
-.cache
-.vscode
-fileStorage
-settings.json
-public/components
-public/_imports.html
-private/oldClient
-nohup.out
-node_modules
-dump

app/.meteor/packages

@@ -1,51 +0,0 @@
-# Meteor packages used by this project, one per line.
-#
-# 'meteor add' and 'meteor remove' will edit this file for you,
-# but you can also edit it by hand.
-
-accounts-password@2.3.1
-random@1.2.1
-underscore@1.0.11
-dburles:mongo-collection-instances
-accounts-google@1.4.0
-email@2.2.2
-meteor-base@1.5.1
-mobile-experience@1.1.0
-mongo@1.16.1
-session@1.2.1
-tracker@1.2.1
-logging@1.3.1
-reload@1.3.1
-ejson@1.1.3
-check@1.3.2
-standard-minifier-js@2.8.1
-shell-server@0.5.0
-ecmascript@0.16.3
-es5-shim@4.8.0
-service-configuration@1.3.1
-dynamic-import@0.7.2
-ddp-rate-limiter@1.1.1
-rate-limit@1.0.9
-mdg:validated-method
-static-html@1.3.2
-aldeed:collection2
-aldeed:schema-index
-accounts-patreon
-bozhao:link-accounts
-peerlibrary:reactive-publish
-simple:rest
-simple:rest-method-mixin
-mikowals:batch-insert
-peerlibrary:subscription-data
-zer0th:meteor-vuetify-loader
-akryum:vue-component
-akryum:vue-router2
-percolate:migrations
-meteortesting:mocha
-ostrio:files
-simple:rest-bearer-token-parser
-simple:rest-json-error-handler
-littledata:synced-cron
-mdg:meteor-apm-agent
-typescript@4.5.4
-seba:minifiers-autoprefixer

app/.meteor/release

@@ -1 +0,0 @@
-METEOR@2.8.1

app/.meteor/versions

@@ -1,129 +0,0 @@
-accounts-base@2.2.5
-accounts-google@1.4.0
-accounts-oauth@1.4.1
-accounts-password@2.3.1
-accounts-patreon@0.1.0
-akryum:npm-check@0.1.2
-akryum:vue-component@0.15.2
-akryum:vue-component-dev-client@0.4.7
-akryum:vue-component-dev-server@0.1.4
-akryum:vue-router2@0.2.3
-aldeed:collection2@3.5.0
-aldeed:schema-index@3.0.0
-allow-deny@1.1.1
-autoupdate@1.8.0
-babel-compiler@7.9.2
-babel-runtime@1.5.1
-base64@1.0.12
-binary-heap@1.0.11
-blaze-tools@1.1.3
-boilerplate-generator@1.7.1
-bozhao:link-accounts@2.6.1
-caching-compiler@1.2.2
-caching-html-compiler@1.2.1
-callback-hook@1.4.0
-check@1.3.2
-coffeescript@2.4.1
-coffeescript-compiler@2.4.1
-dburles:mongo-collection-instances@0.3.6
-ddp@1.4.1
-ddp-client@2.6.1
-ddp-common@1.4.0
-ddp-rate-limiter@1.1.1
-ddp-server@2.6.0
-diff-sequence@1.1.2
-dynamic-import@0.7.2
-ecmascript@0.16.3
-ecmascript-runtime@0.8.0
-ecmascript-runtime-client@0.12.1
-ecmascript-runtime-server@0.11.0
-ejson@1.1.3
-email@2.2.2
-es5-shim@4.8.0
-fetch@0.1.2
-geojson-utils@1.0.11
-google-oauth@1.4.2
-hot-code-push@1.0.4
-html-tools@1.1.3
-htmljs@1.1.1
-http@2.0.0
-id-map@1.1.1
-inter-process-messaging@0.1.1
-lai:collection-extensions@0.3.0
-launch-screen@1.3.0
-littledata:synced-cron@1.5.1
-livedata@1.0.18
-localstorage@1.2.0
-logging@1.3.1
-mdg:meteor-apm-agent@3.5.1
-mdg:validated-method@1.2.0
-meteor@1.10.2
-meteor-base@1.5.1
-meteortesting:browser-tests@1.3.5
-meteortesting:mocha@2.0.3
-meteortesting:mocha-core@8.1.2
-mikowals:batch-insert@1.3.0
-minifier-css@1.6.1
-minifier-js@2.7.5
-minimongo@1.9.0
-mobile-experience@1.1.0
-mobile-status-bar@1.1.0
-modern-browsers@0.1.9
-modules@0.19.0
-modules-runtime@0.13.1
-mongo@1.16.1
-mongo-decimal@0.1.3
-mongo-dev-server@1.1.0
-mongo-id@1.0.8
-mongo-livedata@1.0.12
-npm-mongo@4.11.0
-oauth@2.1.2
-oauth2@1.3.1
-ordered-dict@1.1.0
-ostrio:cookies@2.7.2
-ostrio:files@2.3.2
-patreon-oauth@0.1.0
-peerlibrary:assert@0.3.0
-peerlibrary:check-extension@0.7.0
-peerlibrary:computed-field@0.10.0
-peerlibrary:data-lookup@0.3.0
-peerlibrary:extend-publish@0.6.0
-peerlibrary:fiber-utils@0.10.0
-peerlibrary:reactive-mongo@0.4.1
-peerlibrary:reactive-publish@0.10.0
-peerlibrary:server-autorun@0.8.0
-peerlibrary:subscription-data@0.8.0
-percolate:migrations@1.1.0
-promise@0.12.1
-raix:eventemitter@1.0.0
-random@1.2.1
-rate-limit@1.0.9
-react-fast-refresh@0.2.3
-reactive-dict@1.3.1
-reactive-var@1.0.12
-reload@1.3.1
-retry@1.1.0
-routepolicy@1.1.1
-seba:minifiers-autoprefixer@2.0.1
-service-configuration@1.3.1
-session@1.2.1
-sha@1.0.9
-shell-server@0.5.0
-simple:json-routes@2.3.1
-simple:rest@1.2.1
-simple:rest-bearer-token-parser@1.1.1
-simple:rest-json-error-handler@1.1.1
-simple:rest-method-mixin@1.1.0
-socket-stream-client@0.5.0
-spacebars-compiler@1.3.1
-standard-minifier-js@2.8.1
-static-html@1.3.2
-templating-tools@1.2.2
-tmeasday:check-npm-versions@1.0.2
-tracker@1.2.1
-typescript@4.5.4
-underscore@1.0.11
-url@1.3.2
-webapp@1.13.2
-webapp-hashing@1.1.1
-zer0th:meteor-vuetify-loader@0.1.41

app/client/head.html

@@ -1,39 +0,0 @@
-<head>
-  <link href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900" rel="stylesheet">
-  <link href="https://cdn.jsdelivr.net/npm/@mdi/font@5.x/css/materialdesignicons.min.css" rel="stylesheet">
-  <meta name="viewport" content="width=device-width initial-scale=1.0, user-scalable=no">
-  <meta name="mobile-web-app-capable" content="yes">
-  <meta name="apple-mobile-web-app-capable" content="yes">
-  <link rel="apple-touch-icon" sizes="57x57" href="/apple-touch-icon-57x57.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="60x60" href="/apple-touch-icon-60x60.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="72x72" href="/apple-touch-icon-72x72.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="76x76" href="/apple-touch-icon-76x76.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="114x114" href="/apple-touch-icon-114x114.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="120x120" href="/apple-touch-icon-120x120.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="144x144" href="/apple-touch-icon-144x144.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="152x152" href="/apple-touch-icon-152x152.png?v=lk6WXp6Pmj">
-  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png?v=lk6WXp6Pmj">
-  <link rel="icon" type="image/png" href="/favicon-32x32.png?v=lk6WXp6Pmj" sizes="32x32">
-  <link rel="icon" type="image/png" href="/favicon-194x194.png?v=lk6WXp6Pmj" sizes="194x194">
-  <link rel="icon" type="image/png" href="/favicon-96x96.png?v=lk6WXp6Pmj" sizes="96x96">
-  <link rel="icon" type="image/png" href="/android-chrome-192x192.png?v=lk6WXp6Pmj" sizes="192x192">
-  <link rel="icon" type="image/png" href="/favicon-16x16.png?v=lk6WXp6Pmj" sizes="16x16">
-  <link rel="manifest" href="/manifest.json?v=lk6WXp6Pmj">
-  <link rel="shortcut icon" href="/favicon.ico?v=lk6WXp6Pmj">
-  <meta name="msapplication-TileColor" content="#b91d1d">
-  <meta name="msapplication-TileImage" content="/mstile-144x144.png?v=lk6WXp6Pmj">
-  <meta name="theme-color" content="#d12929">
-
-  <style type="text/css" media="print">
-    @page {
-      margin: 0mm;
-    }
-    html {
-      margin: 0px;
-    }
-    * {
-      -webkit-transition: none !important;
-      transition: none !important;
-    }
-  </style>
-</head>

app/client/index.html

@@ -1,3 +0,0 @@
-<body>
-  <div id="app"></div>
-</body>

app/client/main.js

@@ -1,7 +0,0 @@
-import '/imports/api/simpleSchemaConfig.js';
-import '/imports/client/ui/vueSetup.js';
-import '/imports/client/ui/styles/stylesIndex.js';
-import '/imports/client/config.js';
-import '/imports/client/serviceWorker.js';
-
-import 'ngraph.graph';

app/exampleMeteorSettings.json

@@ -1,6 +0,0 @@
-{
-  "public": {
-    "environment": "production",
-    "disablePatreon": true
-  }
-}

app/imports/api/creature/archive/ArchiveCreatureFiles.js

@@ -1,58 +0,0 @@
-
-import SimpleSchema from 'simpl-schema';
-import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
-import { CreaturePropertySchema } from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { CreatureSchema } from '/imports/api/creature/creatures/Creatures.js';
-let createS3FilesCollection;
-if (Meteor.isServer) {
-  createS3FilesCollection = require('/imports/api/files/server/s3FileStorage.js').createS3FilesCollection
-} else {
-  createS3FilesCollection = require('/imports/api/files/client/s3FileStorage.js').createS3FilesCollection
-}
-
-const ArchiveCreatureFiles = createS3FilesCollection({
-  collectionName: 'archiveCreatureFiles',
-  storagePath: Meteor.isDevelopment ? '../../../../../fileStorage/archiveCreatures' : 'assets/app/archiveCreatures',
-  onBeforeUpload(file) {
-    // Allow upload files under 10MB, and only in json format
-    if (file.size > 10485760) {
-      return 'Please upload with size equal or less than 10MB';
-    }
-    if (!/json/i.test(file.extension)) {
-      return 'Please upload only a JSON file';
-    }
-    return true;
-  },
-  onAfterUpload(file) {
-    if (Meteor.isServer) incrementFileStorageUsed(file.userId, file.size);
-  }
-});
-
-let archiveSchema = new SimpleSchema({
-  meta: {
-    type: Object,
-    blackbox: true,
-  },
-  creature: CreatureSchema,
-  properties: {
-    type: Array,
-  },
-  'properties.$': CreaturePropertySchema,
-  experiences: {
-    type: Array,
-  },
-  'experiences.$': {
-    type: Object,
-    blackbox: true,
-  },
-  logs: {
-    type: Array,
-  },
-  'logs.$': {
-    type: Object,
-    blackbox: true,
-  },
-});
-
-export default ArchiveCreatureFiles;
-export { archiveSchema };

app/imports/api/creature/archive/methods/archiveCreatureToFile.js

@@ -1,78 +0,0 @@
-import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION.js';
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
-
-export function getArchiveObj(creatureId){
-  // Build the archive document
-  const creature = Creatures.findOne(creatureId);
-  const properties = CreatureProperties.find({'ancestors.id': creatureId}).fetch();
-  const experiences = Experiences.find({creatureId}).fetch();
-  const logs = CreatureLogs.find({creatureId}).fetch();
-  let archiveCreature = {
-    meta: {
-      type: 'DiceCloud V2 Creature Archive',
-      schemaVersion: SCHEMA_VERSION,
-      archiveDate: new Date(),
-    },
-    creature,
-    properties,
-    experiences,
-    logs,
-  };
-
-  return archiveCreature;
-}
-
-export function archiveCreature(creatureId){
-  const archive = getArchiveObj(creatureId);
-  const buffer = Buffer.from(JSON.stringify(archive, null, 2));
-  ArchiveCreatureFiles.write(buffer, {
-    fileName: `${archive.creature.name || archive.creature._id}.json`,
-    type: 'application/json',
-    userId: archive.creature.owner,
-    meta: {
-      schemaVersion: SCHEMA_VERSION,
-      creatureId: archive.creature._id,
-      creatureName: archive.creature.name,
-    },
-  }, (error) => {
-    if (error){
-      throw error;
-    } else {
-      removeCreatureWork(creatureId);
-    }
-  }, true);
-}
-
-const archiveCreatureToFile = new ValidatedMethod({
-  name: 'Creatures.methods.archiveCreatureToFile',
-  validate: new SimpleSchema({
-    'creatureId': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  async run({creatureId}) {
-    assertOwnership(creatureId, this.userId);
-    if (Meteor.isServer){
-      archiveCreature(creatureId, this.userId);
-    } else {
-      removeCreatureWork(creatureId);
-    }
-  },
-});
-
-export default archiveCreatureToFile;

app/imports/api/creature/archive/methods/index.js

@@ -1,3 +0,0 @@
-import '/imports/api/creature/archive/methods/archiveCreatureToFile.js';
-import '/imports/api/creature/archive/methods/restoreCreatureFromFile.js';
-import '/imports/api/creature/archive/methods/removeArchiveCreature.js';

app/imports/api/creature/archive/methods/removeArchiveCreature.js

@@ -1,40 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
-import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
-
-const removeArchiveCreature = new ValidatedMethod({
-  name: 'ArchiveCreatureFiles.methods.removeArchiveCreature',
-  validate: new SimpleSchema({
-    'fileId': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  async run({ fileId }) {
-    // fetch the file
-    const file = ArchiveCreatureFiles.findOne({ _id: fileId }).get();
-    if (!file) {
-      throw new Meteor.Error('File not found',
-        'The requested creature archive does not exist');
-    }
-    // Assert ownership
-    const userId = file?.userId;
-    if (!userId || userId !== this.userId) {
-      throw new Meteor.Error('Permission denied',
-        'You can only restore creatures you own');
-    }
-    //Remove the archive once the restore succeeded
-    ArchiveCreatureFiles.remove({ _id: fileId });
-    // Update the user's file storage limits
-    incrementFileStorageUsed(userId, -file.size);
-  },
-});
-
-export default removeArchiveCreature;

app/imports/api/creature/archive/methods/restoreCreatureFromFile.js

@@ -1,104 +0,0 @@
-import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION.js';
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
-import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots.js';
-import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
-import verifyArchiveSafety from '/imports/api/creature/archive/methods/verifyArchiveSafety.js';
-
-let migrateArchive;
-if (Meteor.isServer){
-  migrateArchive = require('/imports/migrations/server/migrateArchive.js').default;
-}
-
-function restoreCreature(archive, userId){
-  if (SCHEMA_VERSION < archive.meta.schemaVersion){
-    throw new Meteor.Error('Incompatible',
-      'The archive file is from a newer version. Update required to read.')
-  }
-
-  // Migrate and verify the archive meets the current schema
-  migrateArchive(archive);
-
-  // Asset that the archive is safe
-  verifyArchiveSafety(archive);
-
-  // Don't upload creatures twice
-  const existingCreature = Creatures.findOne(archive.creature._id, {
-    fields: { _id: 1 }
-  });
-  if (existingCreature) throw new Meteor.Error('Already exists',
-    'The creature you are trying to restore already exists.')
-  
-  // Ensure the user owns the restored creature
-  archive.creature.owner = userId;
-
-  // Insert the creature sub documents
-  // They still have their original _id's
-  Creatures.insert(archive.creature);
-  try {
-    // Add all the properties
-    if (archive.properties && archive.properties.length){
-      CreatureProperties.batchInsert(archive.properties);
-    }
-    if (archive.experiences && archive.experiences.length){
-      Experiences.batchInsert(archive.experiences);
-    }
-    if (archive.logs && archive.logs.length){
-      CreatureLogs.batchInsert(archive.logs);
-    }
-  } catch (e) {
-    // If the above fails, delete the inserted creature
-    removeCreatureWork(archive.creature._id);
-    throw e;
-  }
-}
-
-const restoreCreaturefromFile = new ValidatedMethod({
-  name: 'Creatures.methods.restoreCreaturefromFile',
-  validate: new SimpleSchema({
-    'fileId': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  async run({fileId}) {
-    // fetch the file
-    const file = ArchiveCreatureFiles.findOne({_id: fileId}).get();
-    if (!file){
-      throw new Meteor.Error('File not found',
-      'The requested creature archive does not exist');
-    }
-    // Assert ownership
-    const userId = file?.userId;
-    if (!userId || userId !== this.userId){
-      throw new Meteor.Error('Permission denied',
-      'You can only restore creatures you own');
-    }
-
-    assertHasCharactersSlots(this.userId);
-
-    if (Meteor.isServer){
-      // Read the file data
-      const archive = await ArchiveCreatureFiles.readJSONFile(file);
-      restoreCreature(archive, this.userId);
-    }
-    //Remove the archive once the restore succeeded
-    ArchiveCreatureFiles.remove({ _id: fileId });
-    // Update the user's file storage limits
-    incrementFileStorageUsed(userId, -file.size);
-  },
-});
-
-export default restoreCreaturefromFile;

app/imports/api/creature/archive/methods/verifyArchiveSafety.js

@@ -1,28 +0,0 @@
-import { slice } from 'lodash';
-import PER_CREATURE_LOG_LIMIT from '/imports/api/creature/log/CreatureLogs.js';
-
-export default function verifyArchiveSafety({ meta, creature, properties, experiences, logs }){
-  const creatureId = creature._id;
-
-  // Check lengths of arrays
-  if (logs.length > PER_CREATURE_LOG_LIMIT) {
-    logs = slice(logs, 0, PER_CREATURE_LOG_LIMIT);
-  }
-
-  // Check that everything belongs to the right creature
-  logs.forEach(log => {
-    if (log.creatureId !== creatureId) {
-      throw new Meteor.Error('Malicious log', 'Log contains an entry for the wrong creature');
-    }
-  });
-  experiences.forEach(experience => {
-    if (experience.creatureId !== creatureId) {
-      throw new Meteor.Error('Malicious experience', 'Experiences contains an entry for the wrong creature');
-    }
-  });
-  properties.forEach(prop => {
-    if (prop.ancestors[0].id !== creatureId) {
-      throw new Meteor.Error('Malicious prop', 'Properties contains an entry for the wrong creature');
-    }
-  });
-}

app/imports/api/creature/creatureFolders/CreatureFolders.js

@@ -1,39 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let CreatureFolders = new Mongo.Collection('creatureFolders');
-
-let creatureFolderSchema = new SimpleSchema({
-  name: {
-    type: String,
-    trim: false,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  creatures: {
-    type: Array,
-    defaultValue: [],
-  },
-  'creatures.$': {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-  owner: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  },
-  archived: {
-    type: Boolean,
-    optional: true,
-  },
-  order: {
-    type: Number,
-    defaultValue: 0,
-  },
-});
-
-CreatureFolders.attachSchema(creatureFolderSchema);
-
-import '/imports/api/creature/creatureFolders/methods.js/index.js';
-export default CreatureFolders;

app/imports/api/creature/creatureFolders/methods.js/index.js

@@ -1,4 +0,0 @@
-import '/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js';
-import '/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js';
-import '/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js';
-import '/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js';

app/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js

@@ -1,46 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const insertCreatureFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.insert',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run() {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.insert.denied',
-      'You need to be logged in to insert a folder');
-    }
-    // Limit folders to 50 per user
-    let existingFolders = CreatureFolders.find({
-      owner: userId
-    }, {
-      fields: {order: 1},
-      sort: {order :-1}
-    });
-    if (existingFolders.count() >= 50){
-      throw new Meteor.Error('creatureFolders.methods.insert.denied',
-      'You can not have more than 50 folders');
-    }
-    // Make the new folder the last in the order
-    let order = 0;
-    let lastFolder = existingFolders.fetch()[0];
-    if (lastFolder){
-      order = (lastFolder.order || 0) + 1;
-    }
-    // Insert
-    return CreatureFolders.insert({
-      name: 'Folder',
-      owner: userId,
-      order,
-    });
-  },
-});
-
-export default insertCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js

@@ -1,45 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const moveCreatureToFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.moveCreatureToFolder',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({creatureId, folderId}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to remove a folder');
-    }
-    // Check that this folder is owned by the user
-    if (folderId){
-      let existingFolder = CreatureFolders.findOne(folderId);
-      if (existingFolder.owner !== userId){
-        throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-        'This folder does not belong to you');
-      }
-    }
-    // Remove from other folders
-    CreatureFolders.update({
-      owner: userId
-    }, {
-      $pull: {creatures: creatureId},
-    }, {
-      multi: true,
-    });
-    if (folderId){
-      // Add to this folder
-      CreatureFolders.update(folderId, {
-        $addToSet: {creatures: creatureId},
-      });
-    }
-  },
-});
-
-export default moveCreatureToFolder;

app/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js

@@ -1,31 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const removeCreatureFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.remove',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to remove a folder');
-    }
-    // Check that this folder is owned by the user
-    let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'This folder does not belong to you');
-    }
-    // Remove
-    return CreatureFolders.remove(_id);
-  },
-});
-
-export default removeCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/reorderCreatureFolder.js

@@ -1,43 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const reorderCreatureFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.reorder',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, order}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.reorder.denied',
-      'You need to be logged in to reorder a folder');
-    }
-    // Check that this folder is owned by the user
-    let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
-      throw new Meteor.Error('creatureFolders.methods.reorder.denied',
-      'This folder does not belong to you');
-    }
-    // First give it the new order, it should end in 0.5 putting it between two other docs
-    CreatureFolders.update(_id, {$set: {order}});
-    this.unblock();
-    // Reorder all the folders with integer numbers in this new order
-    CreatureFolders.find({
-      owner: userId
-    }, {
-      fields: {order: 1,},
-      sort: {order: -1}
-    }).forEach((folder, index) => {
-      if (folder.order !== index){
-        CreatureFolders.update(_id, {$set: {order: index}})
-      }
-    });
-  },
-});
-
-export default reorderCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js

@@ -1,31 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const updateCreatureFolderName = new ValidatedMethod({
-  name: 'creatureFolders.methods.updateName',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, name}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to update a folder');
-    }
-    // Check that this folder is owned by the user
-    let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'This folder does not belong to you');
-    }
-    // Update
-    return CreatureFolders.update(_id, {$set: {name}});
-  },
-});
-
-export default updateCreatureFolderName;

app/imports/api/creature/creatureProperties/CreatureProperties.js

@@ -1,112 +0,0 @@
-import { Mongo } from 'meteor/mongo';
-import SimpleSchema from 'simpl-schema';
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import ChildSchema from '/imports/api/parenting/ChildSchema.js';
-import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
-import propertySchemasIndex from '/imports/api/properties/computedPropertySchemasIndex.js';
-import { storedIconsSchema } from '/imports/api/icons/Icons.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let CreatureProperties = new Mongo.Collection('creatureProperties');
-
-let CreaturePropertySchema = new SimpleSchema({
-  _id: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-  _migrationError: {
-    type: String,
-    optional: true,
-  },
-  type: {
-    type: String,
-    allowedValues: Object.keys(propertySchemasIndex),
-  },
-  tags: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.tagCount,
-  },
-  'tags.$': {
-    type: String,
-    max: STORAGE_LIMITS.tagLength,
-  },
-  disabled: {
-    type: Boolean,
-    optional: true,
-  },
-  icon: {
-    type: storedIconsSchema,
-    optional: true,
-    max: STORAGE_LIMITS.icon,
-  },
-  // Reference to the library node that this property was copied from
-  libraryNodeId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    optional: true,
-  },
-});
-
-const DenormalisedOnlyCreaturePropertySchema = new SimpleSchema({
-  // Denormalised flag if this property is inactive on the sheet for any reason
-  // Including being disabled, or a decendent of a disabled property
-  inactive: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // Denormalised flag if this property was made inactive by an inactive
-  // ancestor. True if this property has an inactive ancestor even if this
-  // property is itself inactive
-  deactivatedByAncestor: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // Denormalised flag if this property was made inactive because of its own
-  // state
-  deactivatedBySelf: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // Denormalised flag if this property was made inactive because of a toggle
-  // calculation. Either an ancestor toggle calculation or its own.
-  deactivatedByToggle: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // When this is true on any property, the creature needs to be recomputed
-  dirty: {
-    type: Boolean,
-    // Default to true because new properties cause a recomputation
-    defaultValue: true,
-    optional: true,
-  },
-});
-
-CreaturePropertySchema.extend(DenormalisedOnlyCreaturePropertySchema);
-
-for (let key in propertySchemasIndex) {
-  let schema = new SimpleSchema({});
-  schema.extend(propertySchemasIndex[key]);
-  schema.extend(CreaturePropertySchema);
-  schema.extend(ColorSchema);
-  schema.extend(ChildSchema);
-  schema.extend(SoftRemovableSchema);
-  CreatureProperties.attachSchema(schema, {
-    selector: { type: key }
-  });
-}
-
-export default CreatureProperties;
-export {
-  DenormalisedOnlyCreaturePropertySchema,
-  CreaturePropertySchema,
-};

app/imports/api/creature/creatureProperties/getRootCreatureAncestor.js

@@ -1,5 +0,0 @@
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-export default function getRootCreatureAncestor(property){
-  return Creatures.findOne(property.ancestors[0].id);
-}

app/imports/api/creature/creatureProperties/methods/adjustQuantity.js

@@ -1,63 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-
-const adjustQuantity = new ValidatedMethod({
-  name: 'creatureProperties.adjustQuantity',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, operation, value }) {
-    // Permissions
-    let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-    adjustQuantityWork({ property, operation, value });
-  },
-});
-
-export function adjustQuantityWork({ property, operation, value }) {
-  // Check if property has quantity
-  let schema = CreatureProperties.simpleSchema(property);
-  if (!schema.allowsKey('quantity')) {
-    throw new Meteor.Error(
-      'Adjust quantity failed',
-      `Property of type "${property.type}" doesn't have a quantity`
-    );
-  }
-  if (operation === 'set') {
-    CreatureProperties.update(property._id, {
-      $set: { quantity: value, dirty: true }
-    }, {
-      selector: property
-    });
-  } else if (operation === 'increment') {
-    // value here is 'damage'
-    value = -value;
-    let currentQuantity = property.quantity;
-    if (currentQuantity + value < 0) value = -currentQuantity;
-    CreatureProperties.update(property._id, {
-      $inc: { quantity: value },
-      $set: { dirty: true }
-    }, {
-      selector: property
-    });
-  }
-}
-
-export default adjustQuantity;

app/imports/api/creature/creatureProperties/methods/damageProperty.js

@@ -1,141 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const damageProperty = new ValidatedMethod({
-  name: 'creatureProperties.damage',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({ _id, operation, value }) {
-
-    // Get action context
-    let prop = CreatureProperties.findOne(_id);
-    if (!prop) throw new Meteor.Error(
-      'Damage property failed', 'Property doesn\'t exist'
-    );
-    const creatureId = prop.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-    // Check if property can take damage
-    let schema = CreatureProperties.simpleSchema(prop);
-    if (!schema.allowsKey('damage')) {
-      throw new Meteor.Error(
-        'Damage property failed',
-        `Property of type "${prop.type}" can't be damaged`
-      );
-    }
-
-    // Replace the prop by its actionContext counterpart if possible
-    if (prop.variableName) {
-      const actionContextProp = actionContext.scope[prop.variableName];
-      if (actionContextProp?._id === prop._id) {
-        prop = actionContextProp;
-      }
-    }
-
-    const result = damagePropertyWork({ prop, operation, value, actionContext });
-
-    // Insert the log
-    actionContext.writeLog();
-    return result;
-  },
-});
-
-export function damagePropertyWork({ prop, operation, value, actionContext, logFunction }) {
-
-  // Save the value to the scope before applying the before triggers
-  if (operation === 'increment') {
-    if (value >= 0) {
-      actionContext.scope['$damage'] = value;
-    } else {
-      actionContext.scope['$healing'] = -value;
-    }
-  } else {
-    actionContext.scope['$set'] = value;
-  }
-
-  applyTriggers(actionContext.triggers?.damageProperty?.before, prop, actionContext);
-
-  // fetch the value from the scope after the before triggers, in case they changed them
-  if (operation === 'increment') {
-    if (value >= 0) {
-      value = actionContext.scope['$damage'];
-    } else {
-      value = -actionContext.scope['$healing'];
-    }
-  } else {
-    value = actionContext.scope['$set'];
-  }
-
-  let damage, newValue, increment;
-  if (operation === 'set') {
-    const total = prop.total || 0;
-    // Set represents what we want the value to be after damage
-    // So we need the actual damage to get to that value
-    damage = total - value;
-    // Damage can't exceed total value
-    if (damage > total && !prop.ignoreLowerLimit) damage = total;
-    // Damage must be positive
-    if (damage < 0 && !prop.ignoreUpperLimit) damage = 0;
-    newValue = prop.total - damage;
-    // Write the results
-    CreatureProperties.update(prop._id, {
-      $set: { damage, value: newValue, dirty: true }
-    }, {
-      selector: prop
-    });
-    // Also write it straight to the prop so that it is updated in the actionContext
-    prop.damage = damage;
-    prop.value = newValue;
-    logFunction?.(newValue);
-  } else if (operation === 'increment') {
-    let currentValue = prop.value || 0;
-    let currentDamage = prop.damage || 0;
-    increment = value;
-    // Can't increase damage above the remaining value
-    if (increment > currentValue && !prop.ignoreLowerLimit) increment = currentValue;
-    // Can't decrease damage below zero
-    if (-increment > currentDamage && !prop.ignoreUpperLimit) increment = -currentDamage;
-    damage = currentDamage + increment;
-    newValue = prop.total - damage;
-    // Write the results
-    CreatureProperties.update(prop._id, {
-      $inc: { damage: increment, value: -increment },
-      $set: { dirty: true },
-    }, {
-      selector: prop
-    });
-    // Also write it straight to the prop so that it is updated in the actionContext
-    prop.damage += increment;
-    prop.value -= increment;
-    logFunction?.(increment);
-  }
-
-  applyTriggers(actionContext.triggers?.damageProperty?.after, prop, actionContext);
-
-  if (operation === 'set') {
-    return damage;
-  } else if (operation === 'increment') {
-    return increment;
-  }
-}
-
-export default damageProperty;

app/imports/api/creature/creatureProperties/methods/duplicateProperty.js

@@ -1,96 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import {
-  setLineageOfDocs,
-  renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-var snackbar;
-if (Meteor.isClient) {
-  snackbar = require(
-    '/imports/client/ui/components/snackbars/SnackbarQueue.js'
-  ).snackbar
-}
-
-const DUPLICATE_CHILDREN_LIMIT = 50;
-
-const duplicateProperty = new ValidatedMethod({
-  name: 'creatureProperties.duplicate',
-  validate: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    }
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id }) {
-    let property = CreatureProperties.findOne(_id);
-    let creature = getRootCreatureAncestor(property);
-
-    assertEditPermission(creature, this.userId);
-
-    // Renew the doc ID
-    let randomSrc = DDP.randomStream('duplicateProperty');
-    let propertyId = randomSrc.id();
-    property._id = propertyId;
-
-    // Get all the descendants
-    let nodes = CreatureProperties.find({
-      'ancestors.id': _id,
-      removed: { $ne: true },
-    }, {
-      limit: DUPLICATE_CHILDREN_LIMIT + 1,
-      sort: { order: 1 },
-    }).fetch();
-
-    // Alert the user if the limit was hit
-    if (nodes.length > DUPLICATE_CHILDREN_LIMIT) {
-      nodes.pop();
-      if (Meteor.isClient) {
-        snackbar({
-          text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
-        });
-      }
-    }
-
-    // re-map all the ancestors
-    setLineageOfDocs({
-      docArray: nodes,
-      newAncestry: [
-        ...property.ancestors,
-        { id: propertyId, collection: 'creatureProperties' }
-      ],
-      oldParent: { id: _id, collection: 'creatureProperties' },
-    });
-
-    // Give the docs new IDs without breaking internal references
-    renewDocIds({ docArray: nodes });
-
-    // Order the root node
-    property.order += 0.5;
-
-    // Mark the sheet as needing recompute
-    property.dirty = true;
-
-    // Insert the properties
-    CreatureProperties.batchInsert([property, ...nodes]);
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: property.ancestors[0].id,
-    });
-
-    return propertyId;
-  },
-});
-
-export default duplicateProperty;

app/imports/api/creature/creatureProperties/methods/equipItem.js

@@ -1,51 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
-import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
-
-// Equipping or unequipping an item will also change its parent
-const equipItem = new ValidatedMethod({
-  name: 'creatureProperties.equip',
-  validate({ _id, equipped }) {
-    if (!_id) throw new Meteor.Error('No _id', '_id is required');
-    if (equipped !== true && equipped !== false) {
-      throw new Meteor.Error('No equipped', 'equipped is required to be true or false');
-    }
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, equipped }) {
-    let item = CreatureProperties.findOne(_id);
-    if (item.type !== 'item') throw new Meteor.Error('wrong type',
-      'Equip and unequip can only be performed on items');
-    let creature = getRootCreatureAncestor(item);
-    assertEditPermission(creature, this.userId);
-    CreatureProperties.update(_id, {
-      $set: { equipped, dirty: true },
-    }, {
-      selector: { type: 'item' },
-    });
-    let tag = equipped ? BUILT_IN_TAGS.equipment : BUILT_IN_TAGS.carried;
-    let parentRef = getParentRefByTag(creature._id, tag);
-    if (!parentRef) parentRef = { id: creature._id, collection: 'creatures' };
-
-    organizeDoc.call({
-      docRef: {
-        id: _id,
-        collection: 'creatureProperties',
-      },
-      parentRef,
-      order: Number.MAX_SAFE_INTEGER,
-      skipRecompute: true,
-    });
-  },
-});
-
-export default equipItem;

app/imports/api/creature/creatureProperties/methods/flipToggle.js

@@ -1,47 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const flipToggle = new ValidatedMethod({
-  name: 'creatureProperties.flipToggle',
-  validate({ _id }) {
-    if (!_id) throw new Meteor.Error('No _id', '_id is required');
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id }) {
-    // Permission
-    let property = CreatureProperties.findOne(_id, {
-      fields: { type: 1, ancestors: 1, enabled: 1, disabled: 1 }
-    });
-    if (property.type !== 'toggle') {
-      throw new Meteor.Error('wrong property',
-        'This method can only be applied to toggles');
-    }
-    if (!property.enabled && !property.disabled) {
-      throw new Meteor.Error('Computed toggle',
-        'Can\'t flip a toggle that is computed')
-    }
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Invert the current value, disabled is the canonical store of value
-    const currentValue = !property.disabled;
-    CreatureProperties.update(_id, {
-      $set: {
-        enabled: !currentValue,
-        disabled: currentValue,
-        dirty: true,
-      }
-    }, {
-      selector: { type: 'toggle' },
-    });
-  },
-});
-
-export default flipToggle;

app/imports/api/creature/creatureProperties/methods/getParentRefByTag.js

@@ -1,13 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getParentRefByTag(creatureId, tag){
-  let prop = CreatureProperties.findOne({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    inactive: {$ne: true},
-    tags: tag,
-  }, {
-    sort: {order: 1},
-  });
-  return prop && {id: prop._id, collection: 'creatureProperties'};
-}

app/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js

@@ -1,63 +0,0 @@
-export default function getSlotFillFilter({slot, libraryIds}){
-  let filter = {
-    removed: {$ne: true},
-    $and: []
-  };
-  if (libraryIds){
-    filter['ancestors.id'] = {$in: libraryIds};
-  }
-  if (slot.slotType){
-    filter.$and.push({
-      $or: [{
-        type: slot.slotType
-      },{
-        type: 'slotFiller',
-        slotFillerType: slot.slotType,
-      }]
-    });
-  } else if (slot.type === 'class') {
-    filter.$and.push({
-      $or: [{
-        type: 'classLevel',
-      },{
-        type: 'slotFiller',
-        slotFillerType: 'classLevel',
-      }]
-    });
-    if (slot.variableName) { 
-      filter.variableName = slot.variableName;
-    }
-
-    // Only search for levels the class needs
-    if (slot.missingLevels && slot.missingLevels.length) {
-      filter.level = {$in: slot.missingLevels};
-    } else {
-      filter.level = (slot.level || 0) + 1;
-    }
-  }
-  let tagsOr = [];
-  let tagsNin = [];
-  if (slot.slotTags && slot.slotTags.length){
-    tagsOr.push({tags: {$all: slot.slotTags}});
-  }
-  if (slot.extraTags && slot.extraTags.length){
-    slot.extraTags.forEach(extra => {
-      if (!extra.tags || !extra.tags.length) return;
-      if (extra.operation === 'OR'){
-        tagsOr.push({tags: {$all: extra.tags}});
-      } else if (extra.operation === 'NOT'){
-        tagsNin.push(...extra.tags);
-      }
-    });
-  }
-  if (tagsOr.length){
-    filter.$or = tagsOr;
-  }
-  if (tagsNin.length){
-    filter.$and.push({tags: {$nin: tagsNin}});
-  }
-  if (!filter.$and.length){
-    delete filter.$and;
-  }
-  return filter;
-}

app/imports/api/creature/creatureProperties/methods/index.js

@@ -1,13 +0,0 @@
-import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import '/imports/api/creature/creatureProperties/methods/duplicateProperty.js';
-import '/imports/api/creature/creatureProperties/methods/equipItem.js';
-import '/imports/api/creature/creatureProperties/methods/insertProperty.js';
-import '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-import '/imports/api/creature/creatureProperties/methods/pullFromProperty.js';
-import '/imports/api/creature/creatureProperties/methods/pushToProperty.js';
-import '/imports/api/creature/creatureProperties/methods/restoreProperty.js';
-import '/imports/api/creature/creatureProperties/methods/selectAmmoItem.js';
-import '/imports/api/creature/creatureProperties/methods/softRemoveProperty.js';
-import '/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js';
-import '/imports/api/creature/creatureProperties/methods/flipToggle.js';

app/imports/api/creature/creatureProperties/methods/insertProperty.js

@@ -1,145 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import { getAncestry } from '/imports/api/parenting/parenting.js';
-import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
-import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import { getHighestOrder } from '/imports/api/parenting/order.js';
-
-const insertProperty = new ValidatedMethod({
-  name: 'creatureProperties.insert',
-  validate: new SimpleSchema({
-    creatureProperty: {
-      type: Object,
-      blackbox: true,
-    },
-    parentRef: RefSchema,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ creatureProperty, parentRef }) {
-    // get the new ancestry for the properties
-    let { parentDoc, ancestors } = getAncestry({ parentRef });
-
-    // Check permission to edit
-    let rootCreature;
-    if (parentRef.collection === 'creatures') {
-      rootCreature = parentDoc;
-    } else if (parentRef.collection === 'creatureProperties') {
-      rootCreature = getRootCreatureAncestor(parentDoc);
-    } else {
-      throw `${parentRef.collection} is not a valid parent collection`
-    }
-    assertEditPermission(rootCreature, this.userId);
-
-    creatureProperty.parent = parentRef;
-    creatureProperty.ancestors = ancestors;
-
-    return insertPropertyWork({
-      property: creatureProperty,
-      creature: rootCreature,
-    });
-  },
-});
-
-const insertPropertyAsChildOfTag = new ValidatedMethod({
-  name: 'creatureProperties.insertAsChildOfTag',
-  validate: new SimpleSchema({
-    creatureProperty: {
-      type: Object,
-      blackbox: true,
-    },
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    tag: {
-      type: String,
-      max: 20,
-    },
-    tagDefaultName: {
-      type: String,
-      max: 20,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ creatureProperty, creatureId, tag, tagDefaultName }) {
-    let parentRef = getParentRefByTag(creatureId, tag);
-
-    if (!parentRef) {
-      // Use the creature as the parent and mark that we need to insert the folder first later
-      var insertFolderFirst = true;
-      parentRef = { id: creatureId, collection: 'creatures' };
-    }
-
-    // get the new ancestry for the properties
-    let { parentDoc, ancestors } = getAncestry({ parentRef });
-
-    // Check permission to edit
-    let rootCreature;
-    if (parentRef.collection === 'creatures') {
-      rootCreature = parentDoc;
-    } else if (parentRef.collection === 'creatureProperties') {
-      rootCreature = getRootCreatureAncestor(parentDoc);
-    } else {
-      throw `${parentRef.collection} is not a valid parent collection`
-    }
-    assertEditPermission(rootCreature, this.userId);
-
-    // Add the folder first if we need to
-    if (insertFolderFirst) {
-      let order = getHighestOrder({
-        collection: CreatureProperties,
-        ancestorId: parentRef.id,
-      }) + 1;
-      let id = CreatureProperties.insert({
-        type: 'folder',
-        name: tagDefaultName || (tag.charAt(0).toUpperCase() + tag.slice(1)),
-        tags: [tag],
-        parent: parentRef,
-        ancestors: [parentRef],
-        order,
-      });
-      // Make the folder our new parent
-      let newParentRef = { id, collection: 'creatureProperties' };
-      ancestors = [parentRef, newParentRef];
-      parentRef = newParentRef;
-      creatureProperty.order = order + 1;
-    }
-
-    creatureProperty.parent = parentRef;
-    creatureProperty.ancestors = ancestors;
-
-    return insertPropertyWork({
-      property: creatureProperty,
-      creature: rootCreature,
-    });
-  },
-});
-
-export function insertPropertyWork({ property, creature }) {
-  delete property._id;
-  property.dirty = true;
-  let _id = CreatureProperties.insert(property);
-  // Tree structure changed by insert, reorder the tree
-  reorderDocs({
-    collection: CreatureProperties,
-    ancestorId: creature._id,
-  });
-  return _id;
-}
-
-export default insertProperty;
-export { insertPropertyAsChildOfTag };

app/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js

@@ -1,245 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import LibraryNodes from '/imports/api/library/LibraryNodes.js';
-import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import {
-  setLineageOfDocs,
-  getAncestry,
-  renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import { setDocToLastOrder } from '/imports/api/parenting/order.js';
-import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
-
-const insertPropertyFromLibraryNode = new ValidatedMethod({
-  name: 'creatureProperties.insertPropertyFromLibraryNode',
-  validate: new SimpleSchema({
-    nodeIds: {
-      type: Array,
-      max: 20,
-    },
-    'nodeIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    parentRef: {
-      type: RefSchema,
-    },
-    order: {
-      type: Number,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ nodeIds, parentRef, order }) {
-    // get the new ancestry for the properties
-    let { parentDoc, ancestors } = getAncestry({ parentRef });
-
-    // Check permission to edit
-    let rootCreature;
-    if (parentRef.collection === 'creatures') {
-      rootCreature = parentDoc;
-    } else if (parentRef.collection === 'creatureProperties') {
-      rootCreature = getRootCreatureAncestor(parentDoc);
-    } else {
-      throw `${parentRef.collection} is not a valid parent collection`
-    }
-    assertEditPermission(rootCreature, this.userId);
-
-    // {libraryId: hasViewPermission}
-    //let libraryPermissionMemoir = {};
-    let node;
-    nodeIds.forEach(nodeId => {
-      // TODO: Check library view permission for each node before starting
-      node = insertPropertyFromNode(nodeId, ancestors, order);
-    });
-
-    // get one of the root inserted docs
-    let rootId = node._id;
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: rootCreature._id,
-    });
-    // Return the docId of the last property, the inserted root property
-    return rootId;
-  },
-});
-
-function insertPropertyFromNode(nodeId, ancestors, order) {
-  // Fetch the library node and its decendents, provided they have not been
-  // removed
-  // TODO: Check permission to read the library this node is in
-  let node = LibraryNodes.findOne({
-    _id: nodeId,
-    removed: { $ne: true },
-  });
-  if (!node) {
-    if (Meteor.isClient) return;
-    else {
-      throw new Meteor.Error(
-        'Insert property from library failed',
-        `No library document with id '${nodeId}' was found`
-      );
-    }
-  }
-  let oldParent = node.parent;
-  let nodes = LibraryNodes.find({
-    'ancestors.id': nodeId,
-    removed: { $ne: true },
-  }).fetch();
-
-  // Convert all references into actual nodes
-  nodes = reifyNodeReferences(nodes);
-
-  // The root node is first in the array of nodes
-  // It must get the first generated ID to prevent flickering
-  nodes = [node, ...nodes];
-
-  // set libraryNodeIds
-  storeLibraryNodeReferences(nodes);
-
-  // re-map all the ancestors
-  setLineageOfDocs({
-    docArray: nodes,
-    newAncestry: ancestors,
-    oldParent,
-  });
-
-  // Give the docs new IDs without breaking internal references
-  renewDocIds({
-    docArray: nodes,
-    collectionMap: { 'libraryNodes': 'creatureProperties' }
-  });
-
-  // Order the root node
-  if (order === undefined) {
-    setDocToLastOrder({
-      collection: CreatureProperties,
-      doc: node,
-    });
-  } else {
-    node.order = order;
-  }
-
-  // Mark all nodes as dirty
-  dirtyNodes(nodes);
-
-  // Insert the creature properties
-  CreatureProperties.batchInsert(nodes);
-  return node;
-}
-
-function storeLibraryNodeReferences(nodes) {
-  nodes.forEach(node => {
-    if (node.libraryNodeId) return;
-    node.libraryNodeId = node._id;
-  });
-}
-
-function dirtyNodes(nodes) {
-  nodes.forEach(node => {
-    node.dirty = true;
-  });
-}
-
-// Covert node references into actual nodes
-// TODO: check permissions for each library a reference node references
-function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0) {
-  depth += 1;
-  // New nodes added this function
-  let newNodes = [];
-
-  // Filter out the reference nodes we replace
-  let resultingNodes = nodes.filter(node => {
-    // This isn't a reference node, continue as normal
-    if (node.type !== 'reference') return true;
-
-    // We have gone too deep, keep the reference node as an error
-    if (depth >= 10) {
-      if (Meteor.isClient) console.warn('Reference depth limit exceeded');
-      node.cache = { error: 'Reference depth limit exceeded' };
-      return true;
-    }
-
-    let referencedNode
-    try {
-      referencedNode = fetchDocByRef(node.ref);
-      referencedNode.order = node.order;
-      // We are definitely replacing this node, so add it to the list
-      visitedRefs.add(node._id);
-    } catch (e) {
-      node.cache = { error: e.reason || e.message || e.toString() };
-      return true;
-    }
-
-    // Get all the descendants of the referenced node
-    let descendents = LibraryNodes.find({
-      'ancestors.id': referencedNode._id,
-      removed: { $ne: true },
-    }, {
-      sort: { order: 1 },
-    }).fetch();
-
-    // We are adding the referenced node and its descendants
-    let addedNodes = [referencedNode, ...descendents];
-
-    // re-map all the ancestors to parent the new sub-tree into our existing
-    // node tree
-    setLineageOfDocs({
-      docArray: addedNodes,
-      newAncestry: node.ancestors,
-      oldParent: referencedNode.parent,
-    });
-
-    // Filter all the looped references
-    addedNodes = addedNodes.filter(addedNode => {
-      // Add all non-reference nodes
-      if (addedNode.type !== 'reference') {
-        return true;
-      }
-      // If this exact reference has already been resolved before, filter it out
-      if (visitedRefs.has(addedNode._id)) {
-        return false;
-      } else {
-        // Otherwise mark it as visited, and keep it
-        visitedRefs.add(addedNode._id);
-        return true;
-      }
-    });
-
-    // Before renewing Ids make sure the library node reference is stored
-    storeLibraryNodeReferences(addedNodes);
-
-    // Give the new referenced sub-tree new ids
-    // The referenced node must get the id of the ref node so that the
-    // descendants of the ref node keep their ancestry intact
-    renewDocIds({
-      docArray: addedNodes,
-      idMap: { [referencedNode._id]: node._id },
-    });
-
-    // Reify the subtree as well with recursion
-    addedNodes = reifyNodeReferences(addedNodes, visitedRefs, depth);
-
-    // Store the new nodes from this inner loop without altering the array
-    // we are looping over
-    newNodes.push(...addedNodes);
-  });
-
-  // We are done filtering the array, we can add the new nodes to it
-  resultingNodes.push(...newNodes);
-
-  return resultingNodes;
-}
-
-export default insertPropertyFromLibraryNode;

app/imports/api/creature/creatureProperties/methods/pullFromProperty.js

@@ -1,32 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const pullFromProperty = new ValidatedMethod({
-  name: 'creatureProperties.pull',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, itemId }) {
-    // Permissions
-    let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-    CreatureProperties.update(_id, {
-      $pull: { [path.join('.')]: { _id: itemId } },
-      $set: { dirty: true }
-    }, {
-      selector: { type: property.type },
-      getAutoValues: false,
-    });
-  }
-});
-
-export default pullFromProperty;

app/imports/api/creature/creatureProperties/methods/pushToProperty.js

@@ -1,49 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { get } from 'lodash';
-
-const pushToProperty = new ValidatedMethod({
-  name: 'creatureProperties.push',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, value }) {
-    // Permissions
-    let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    let joinedPath = path.join('.');
-
-    // Respect maxCount
-    let schema = CreatureProperties.simpleSchema(property);
-    let maxCount = schema.get(joinedPath, 'maxCount');
-
-    if (Number.isFinite(maxCount)) {
-      let array = get(property, path);
-      let currentCount = array ? array.length : 0;
-      if (currentCount >= maxCount) {
-        throw new Meteor.Error(
-          'Array is full',
-          `Cannot have more than ${maxCount} values`
-        );
-      }
-    }
-
-    // Do work
-    CreatureProperties.update(_id, {
-      $push: { [joinedPath]: value },
-      $set: { dirty: true },
-    }, {
-      selector: { type: property.type },
-    });
-  }
-});
-
-export default pushToProperty;

app/imports/api/creature/creatureProperties/methods/restoreProperty.js

@@ -1,36 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { restore } from '/imports/api/parenting/softRemove.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const restoreProperty = new ValidatedMethod({
-  name: 'creatureProperties.restore',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id }) {
-    // Permissions
-    let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-    restore({
-      _id,
-      collection: CreatureProperties,
-      extraUpdates: {
-        $set: { dirty: true }
-      },
-    });
-  }
-});
-
-export default restoreProperty;

app/imports/api/creature/creatureProperties/methods/selectAmmoItem.js

@@ -1,46 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-
-const selectAmmoItem = new ValidatedMethod({
-  name: 'creatureProperties.selectAmmoItem',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    itemId: SimpleSchema.RegEx.Id,
-    itemConsumedIndex: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ actionId, itemId, itemConsumedIndex }) {
-    // Permissions
-    let action = CreatureProperties.findOne(actionId);
-    let rootCreature = getRootCreatureAncestor(action);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Check that this index has a document to edit
-    let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
-    if (!itemConsumed) {
-      throw new Meteor.Error('Resouce not found',
-        'Could not set ammo, because the ammo document was not found');
-    }
-    let itemToLink = CreatureProperties.findOne(itemId);
-    if (!itemToLink) {
-      throw new Meteor.Error('Item not found',
-        'Could not set ammo: the item was not found');
-    }
-    let path = `resources.itemsConsumed.${itemConsumedIndex}.itemId`;
-    CreatureProperties.update(actionId, {
-      $set: { [path]: itemId, dirty: true }
-    }, {
-      selector: action,
-    });
-  },
-});
-
-export default selectAmmoItem;

app/imports/api/creature/creatureProperties/methods/softRemoveProperty.js

@@ -1,30 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const softRemoveProperty = new ValidatedMethod({
-  name: 'creatureProperties.softRemove',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id }) {
-    // Permissions
-    let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-    softRemove({ _id, collection: CreatureProperties });
-  }
-});
-
-export default softRemoveProperty;

app/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js

@@ -1,49 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const updateCreatureProperty = new ValidatedMethod({
-  name: 'creatureProperties.update',
-  validate({ _id, path }) {
-    if (!_id) throw new Meteor.Error('No _id', '_id is required');
-    // We cannot change these fields with a simple update
-    switch (path[0]) {
-      case 'type':
-      case 'order':
-      case 'parent':
-      case 'ancestors':
-      case 'damage':
-        throw new Meteor.Error('Permission denied',
-          'This property can\'t be updated directly');
-    }
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, value }) {
-    // Permission
-    let property = CreatureProperties.findOne(_id, {
-      fields: { type: 1, ancestors: 1 }
-    });
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    let pathString = path.join('.');
-    let modifier;
-    // unset empty values
-    if (value === null || value === undefined) {
-      modifier = { $unset: { [pathString]: 1 }, $set: { dirty: true } };
-    } else {
-      modifier = { $set: { [pathString]: value, dirty: true } };
-    }
-    CreatureProperties.update(_id, modifier, {
-      selector: { type: property.type },
-    });
-  },
-});
-
-export default updateCreatureProperty;

app/imports/api/creature/creatureProperties/recomputeCreaturesByProperty.js

@@ -1,12 +0,0 @@
-import computeCreature from '/imports/api/engine/computeCreature.js';
-
-/**
- * Recomputes all ancestor creatures of this property
- */
-export default function recomputeCreaturesByProperty(property){
-  for (let ref of property.ancestors){
-    if (ref.collection === 'creatures') {
-      computeCreature.call(ref.id);
-    }
-  }
-}

app/imports/api/creature/creatures/CreatureVariables.js

@@ -1,21 +0,0 @@
-//set up the collection for creature variables
-let CreatureVariables = new Mongo.Collection('creatureVariables');
-
-// Unique index on _creatureId
-if (Meteor.isServer) {
-  CreatureVariables._ensureIndex({ _creatureId: 1 }, { unique: true })
-}
-
-/** No schema because the structure isn't known until compute time
- * Expect documents to looke like:
- * {
- *   _id: "nE8Ngd6K4L4jSxLY2",
- *   _creatureId: "nE8Ngd6K4L4jSxLY2", // indexed reference to the creature
- *   explicitlyDefinedVariableName: {...some creatureProperty}
- *   implicitVariableName: {value: 10},
- *   undefinedVariableName: {},
- * }
- * Where top level fields that don't start with `_` are variables on the sheet
-**/
-
-export default CreatureVariables;

app/imports/api/creature/creatures/Creatures.js

@@ -1,203 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import deathSaveSchema from '/imports/api/properties/subSchemas/DeathSavesSchema.js'
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import SharingSchema from '/imports/api/sharing/SharingSchema.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-//set up the collection for creatures
-let Creatures = new Mongo.Collection('creatures');
-
-let CreatureSettingsSchema = new SimpleSchema({
-  //slowed down by carrying too much?
-  useVariantEncumbrance: {
-    type: Boolean,
-    optional: true,
-  },
-  //hide spellcasting tab
-  hideSpellcasting: {
-    type: Boolean,
-    optional: true,
-  },
-  //hide rest buttons
-  hideRestButtons: {
-    type: Boolean,
-    optional: true,
-  },
-  // Swap around the modifier and stat
-  swapStatAndModifier: {
-    type: Boolean,
-    optional: true,
-  },
-  // Hide all the unused stats
-  hideUnusedStats: {
-    type: Boolean,
-    optional: true,
-  },
-  // Show the tree tab
-  showTreeTab: {
-    type: Boolean,
-    optional: true,
-  },
-  // Hide the spells tab
-  hideSpellsTab: {
-    type: Boolean,
-    optional: true,
-  },
-  // Hide calculation errors
-  hideCalculationErrors: {
-    type: Boolean,
-    optional: true,
-  },
-  // How much each hitDice resets on a long rest
-  hitDiceResetMultiplier: {
-    type: Number,
-    optional: true,
-    min: 0,
-    max: 1,
-  },
-  discordWebhook: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.url,
-  },
-});
-
-let CreatureSchema = new SimpleSchema({
-  // Strings
-  name: {
-    type: String,
-    defaultValue: '',
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  alignment: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  gender: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  picture: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.url,
-  },
-  avatarPicture: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.url,
-  },
-
-  // Libraries
-  allowedLibraries: {
-    type: Array,
-    optional: true,
-    maxCount: 100,
-  },
-  'allowedLibraries.$': {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-  allowedLibraryCollections: {
-    type: Array,
-    optional: true,
-    maxCount: 100,
-  },
-  'allowedLibraryCollections.$': {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-
-  // Mechanics
-  deathSave: {
-    type: deathSaveSchema,
-    defaultValue: {},
-  },
-  // Stats that are computed and denormalised outside of recomputation
-  denormalizedStats: {
-    type: Object,
-    defaultValue: {},
-  },
-  // Sum of all XP gained by this character
-  'denormalizedStats.xp': {
-    type: SimpleSchema.Integer,
-    defaultValue: 0,
-  },
-  // Sum of all levels granted by milestone XP
-  'denormalizedStats.milestoneLevels': {
-    type: SimpleSchema.Integer,
-    defaultValue: 0,
-  },
-  // Does the character need a recompute?
-  dirty: {
-    type: Boolean,
-    optional: true,
-  },
-  // Version of computation engine that was last used to compute this creature
-  computeVersion: {
-    type: String,
-    optional: true,
-  },
-  type: {
-    type: String,
-    defaultValue: 'pc',
-    allowedValues: ['pc', 'npc', 'monster'],
-  },
-  damageMultipliers: {
-    type: Object,
-    blackbox: true,
-    defaultValue: {}
-  },
-  variables: {
-    type: Object,
-    blackbox: true,
-    defaultValue: {}
-  },
-  computeErrors: {
-    type: Array,
-    optional: true,
-  },
-  'computeErrors.$': {
-    type: Object,
-  },
-  'computeErrors.$.type': {
-    type: String,
-  },
-  'computeErrors.$.details': {
-    type: Object,
-    blackbox: true,
-    optional: true,
-  },
-
-  // Tabletop
-  tabletop: {
-    type: String,
-    regEx: SimpleSchema.RegEx.id,
-    optional: true,
-  },
-  initiativeRoll: {
-    type: SimpleSchema.Integer,
-    optional: true,
-  },
-
-  // Settings
-  settings: {
-    type: CreatureSettingsSchema,
-    defaultValue: {},
-  },
-});
-
-CreatureSchema.extend(ColorSchema);
-CreatureSchema.extend(SharingSchema);
-
-Creatures.attachSchema(CreatureSchema);
-
-
-
-export default Creatures;
-export { CreatureSchema };
-
-import '/imports/api/engine/actions/doAction.js';

app/imports/api/creature/creatures/creaturePermissions.js

@@ -1,29 +0,0 @@
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {
-  assertEditPermission as editPermission,
-  assertViewPermission as viewPermission,
-  assertOwnership as ownership
-} from '/imports/api/sharing/sharingPermissions.js';
-
-function getCreature(creature, fields){
-  if (typeof creature === 'string'){
-    return Creatures.findOne(creature, {fields});
-  } else {
-    return creature;
-  }
-}
-
-export function assertOwnership(creature, userId){
-  creature = getCreature(creature, {owner: 1});
-  ownership(creature, userId);
-}
-
-export function assertEditPermission(creature, userId) {
-  creature = getCreature(creature, {owner: 1, writers: 1});
-  editPermission(creature, userId);
-}
-
-export function assertViewPermission(creature, userId) {
-  creature = getCreature(creature, {owner: 1, readers:1, writers: 1, public: 1});
-  viewPermission(creature, userId);
-}

app/imports/api/creature/creatures/defaultCharacterProperties.js

@@ -1,47 +0,0 @@
-import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
-
-export default function defaultCharacterProperties(creatureId){
-  if (!creatureId) throw 'creatureId is required';
-  const creatureRef = {collection: 'creatures', id: creatureId};
-  let randomSrc = DDP.randomStream('defaultProperties');
-  const inventoryId = randomSrc.id();
-  const inventoryRef = {collection: 'creatureProperties', id: inventoryId};
-  return [
-    {
-      type: 'propertySlot',
-      name: 'Ruleset',
-      description: {text: 'Choose a starting point for your character, this will define the basic setup of your character sheet. Without a base ruleset, your sheet will be empty.'},
-      slotTags: ['base'],
-      tags: [],
-      quantityExpected: {calculation: '1'},
-      hideWhenFull: true,
-      spaceLeft: 1,
-      totalFilled: 0,
-      order: 0,
-      parent: creatureRef,
-      ancestors: [creatureRef],
-    }, {
-      _id: inventoryId,
-      type: 'folder',
-      name: 'Inventory',
-      tags: [BUILT_IN_TAGS.inventory],
-      order: 1,
-      parent: creatureRef,
-      ancestors: [creatureRef],
-    }, {
-      type: 'folder',
-      name: 'Equipment',
-      tags: [BUILT_IN_TAGS.equipment],
-      order: 2,
-      parent: inventoryRef,
-      ancestors: [creatureRef, inventoryRef],
-    }, {
-      type: 'folder',
-      name: 'Carried',
-      tags: [BUILT_IN_TAGS.carried],
-      order: 3,
-      parent: inventoryRef,
-      ancestors: [creatureRef, inventoryRef],
-    },
-  ];
-}

app/imports/api/creature/creatures/getCreatureUrlName.js

@@ -1,5 +0,0 @@
-import getSlug from 'speakingurl';
-
-export default function getCreatureUrlName({name}){
-  return getSlug(name, {maintainCase: true}) || '-';
-}

app/imports/api/creature/creatures/methods/assertHasCharacterSlots.js

@@ -1,22 +0,0 @@
-import { getUserTier } from '/imports/api/users/patreon/tiers.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-export default function assertHasCharactersSlots(userId) {
-  if (characterSlotsRemaining(userId) <= 0) {
-    throw new Meteor.Error('characterSlotLimit',
-      'No character slots left')
-  }
-}
-
-export function characterSlotsRemaining(userId) {
-  let tier = getUserTier(userId);
-  const currentCharacterCount = Creatures.find({
-    owner: userId,
-  }, {
-    fields: { _id: 1 },
-  }).count();
-  if (tier.characterSlots === -1) {
-    return Number.POSITIVE_INFINITY;
-  }
-  return tier.characterSlots - currentCharacterCount;
-}

app/imports/api/creature/creatures/methods/changeAllowedLibraries.js

@@ -1,90 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import SimpleSchema from 'simpl-schema';
-import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
-
-const changeAllowedLibraries = new ValidatedMethod({
-  name: 'creatures.changeAllowedLibraries',
-  mixins: [RateLimiterMixin, simpleSchemaMixin],
-  schema: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    allowedLibraries: {
-      type: Array,
-      optional: true,
-      maxCount: 100,
-    },
-    'allowedLibraries.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    allowedLibraryCollections: {
-      type: Array,
-      optional: true,
-      maxCount: 100,
-    },
-    'allowedLibraryCollections.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }),
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ _id, allowedLibraries, allowedLibraryCollections }) {
-    let creature = Creatures.findOne(_id);
-    assertEditPermission(creature, this.userId);
-    let $set;
-    if (allowedLibraries) {
-      $set = { allowedLibraries }
-    }
-    if (allowedLibraryCollections) {
-      if (!$set) $set = {};
-      $set.allowedLibraryCollections = allowedLibraryCollections;
-    }
-    if (!$set) return;
-    Creatures.update(_id, { $set });
-  },
-});
-
-const toggleAllUserLibraries = new ValidatedMethod({
-  name: 'creatures.removeLibraryLimits',
-  mixins: [RateLimiterMixin, simpleSchemaMixin],
-  schema: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    value: {
-      type: Boolean,
-    },
-  }),
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ _id, value }) {
-    if (value) {
-      Creatures.update(_id, {
-        $unset: {
-          allowedLibraryCollections: 1,
-          allowedLibraries: 1,
-        },
-      });
-    } else {
-      Creatures.update(_id, {
-        $set: {
-          allowedLibraryCollections: [],
-          allowedLibraries: [],
-        },
-      });
-    }
-  },
-});
-
-export { changeAllowedLibraries, toggleAllUserLibraries };

app/imports/api/creature/creatures/methods/index.js

@@ -1,5 +0,0 @@
-import '/imports/api/creature/creatures/methods/insertCreature.js';
-import '/imports/api/creature/creatures/methods/removeCreature.js';
-import '/imports/api/creature/creatures/methods/restCreature.js';
-import '/imports/api/creature/creatures/methods/updateCreature.js';
-import '/imports/api/creature/creatures/methods/changeAllowedLibraries.js';

app/imports/api/creature/creatures/methods/insertCreature.js

@@ -1,104 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
-import Creatures, { CreatureSchema } from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import defaultCharacterProperties from '/imports/api/creature/creatures/defaultCharacterProperties.js';
-import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots.js';
-import getSlotFillFilter from '/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js';
-import getCreatureLibraryIds from '/imports/api/library/getCreatureLibraryIds.js';
-import LibraryNodes from '/imports/api/library/LibraryNodes.js';
-import { insertExperienceForCreature } from '/imports/api/creature/experience/Experiences.js';
-import SimpleSchema from 'simpl-schema';
-
-const insertCreature = new ValidatedMethod({
-  name: 'creatures.insertCreature',
-  mixins: [RateLimiterMixin, simpleSchemaMixin],
-  schema: CreatureSchema.pick(
-    'name',
-    'gender',
-    'alignment',
-    'allowedLibraries',
-    'allowedLibraryCollections',
-  ).extend({
-    'startingLevel': {
-      type: SimpleSchema.Integer,
-      min: 0,
-    },
-  }),
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({ name, gender, alignment, startingLevel,
-    allowedLibraries, allowedLibraryCollections }) {
-    const userId = this.userId
-    if (!userId) {
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-        'You need to be logged in to insert a creature');
-    }
-
-    assertHasCharactersSlots(userId);
-
-    // Create the creature document
-    let creatureId = Creatures.insert({
-      owner: userId,
-      name,
-      gender,
-      alignment,
-      allowedLibraries,
-      allowedLibraryCollections,
-    });
-
-    // Insert experience to get character to starting level
-    if (startingLevel) {
-      insertExperienceForCreature({
-        experience: {
-          name: 'Starting level',
-          levels: startingLevel,
-          creatureId
-        },
-        creatureId,
-        userId,
-      });
-    }
-
-    // Insert the default properties
-    // Not batchInsert because we want the properties cleaned by the schema
-    let baseId, rulesetSlot;
-    defaultCharacterProperties(creatureId).forEach(prop => {
-      let id = CreatureProperties.insert(prop);
-      if (prop.name === 'Ruleset') {
-        baseId = id;
-        rulesetSlot = prop;
-      }
-    });
-
-    // If the user only has a single ruleset subscribed, use it by default
-    if (Meteor.isServer) {
-      insertDefaultRuleset(creatureId, baseId, userId, rulesetSlot);
-    }
-
-    return creatureId;
-  },
-});
-
-// If the user only has a single ruleset subscribed, insert it by default
-function insertDefaultRuleset(creatureId, baseId, userId, slot) {
-  const libraryIds = getCreatureLibraryIds(creatureId, userId);
-  const filter = getSlotFillFilter({ slot, libraryIds });
-  const fillCursor = LibraryNodes.find(filter, { fields: { _id: 1 } });
-  const numRulesets = fillCursor.count();
-  if (numRulesets === 1) {
-    const ruleset = fillCursor.fetch()[0]
-    insertPropertyFromLibraryNode.call({
-      nodeIds: [ruleset._id],
-      parentRef: { id: baseId, collection: 'creatureProperties' },
-      order: 0.5,
-    });
-  }
-}
-
-export default insertCreature;

app/imports/api/creature/creatures/methods/removeCreature.js

@@ -1,43 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-
-function removeRelatedDocuments(creatureId){
-  CreatureVariables.remove({_creatureId: creatureId});
-  CreatureProperties.remove({'ancestors.id': creatureId});
-  CreatureLogs.remove({creatureId});
-  Experiences.remove({creatureId});
-}
-
-const removeCreature = new ValidatedMethod({
-  name: 'Creatures.methods.removeCreature', // DDP method name
-  validate: new SimpleSchema({
-    charId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({charId}) {
-    assertOwnership(charId, this.userId)
-    this.unblock();
-    removeCreatureWork(charId)
-  },
-});
-
-export function removeCreatureWork(creatureId){
-  Creatures.remove(creatureId);
-  removeRelatedDocuments(creatureId);
-}
-
-export default removeCreature;

app/imports/api/creature/creatures/methods/restCreature.js

@@ -1,170 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { union } from 'lodash';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-
-const restCreature = new ValidatedMethod({
-  name: 'creature.methods.rest',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    restType: {
-      type: String,
-      allowedValues: ['shortRest', 'longRest'],
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ creatureId, restType }) {
-    // Get action context
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-    // Join, sort, and apply before triggers
-    const beforeTriggers = union(
-      actionContext.triggers.anyRest?.before, actionContext.triggers[restType]?.before
-    ).sort((a, b) => a.order - b.order);
-    applyTriggers(beforeTriggers, null, actionContext);
-
-    // Rest
-    actionContext.addLog({
-      name: restType === 'shortRest' ? 'Short rest' : 'Long rest',
-    });
-    doRestWork(restType, actionContext);
-
-    // Join, sort, and apply after triggers
-    const afterTriggers = union(
-      actionContext.triggers.anyRest?.after, actionContext.triggers[restType]?.after
-    ).sort((a, b) => a.order - b.order);
-    applyTriggers(afterTriggers, null, actionContext);
-
-    // Insert log
-    actionContext.writeLog();
-  },
-});
-
-function doRestWork(restType, actionContext) {
-  const creatureId = actionContext.creature._id;
-  // Long rests reset short rest properties as well
-  let resetFilter;
-  if (restType === 'shortRest') {
-    resetFilter = 'shortRest'
-  } else {
-    resetFilter = { $in: ['shortRest', 'longRest'] }
-  }
-  resetProperties(creatureId, resetFilter, actionContext);
-
-  // Reset half hit dice on a long rest, starting with the highest dice
-  if (restType === 'longRest') {
-    resetHitDice(creatureId, actionContext);
-  }
-}
-
-export function resetProperties(creatureId, resetFilter, actionContext) {
-  // Only apply to active properties
-  const filter = {
-    'ancestors.id': creatureId,
-    reset: resetFilter,
-    removed: { $ne: true },
-    inactive: { $ne: true },
-  };
-  // update all attribute's damage
-  const attributeFilter = {
-    ...filter,
-    type: 'attribute',
-    damage: { $nin: [0, undefined] },
-  }
-  CreatureProperties.find(attributeFilter).forEach(prop => {
-    damagePropertyWork({
-      prop,
-      operation: 'increment',
-      value: -prop.damage ?? 0,
-      actionContext,
-      logFunction(increment) {
-        actionContext.addLog({
-          name: prop.name,
-          value: increment < 0 ? `Restored ${-increment}` : `Removed ${-increment}`
-        });
-      }
-    });
-  });
-  // Update all action-like properties' usesUsed
-  const actionFilter = {
-    ...filter,
-    type: {
-      $in: ['action', 'spell']
-    },
-    usesUsed: { $nin: [0, undefined] },
-  };
-  CreatureProperties.find(actionFilter, {
-    fields: { name: 1, usesUsed: 1 }
-  }).forEach(prop => {
-    actionContext.addLog({
-      name: prop.name,
-      value: prop.usesUsed >= 0 ? `Restored ${prop.usesUsed} uses` : `Removed ${-prop.usesUsed} uses`
-    });
-  });
-  CreatureProperties.update(actionFilter, {
-    $set: {
-      usesUsed: 0,
-      dirty: true,
-    }
-  }, {
-    selector: { type: 'action' },
-    multi: true,
-  });
-}
-
-function resetHitDice(creatureId, actionContext) {
-  let hitDice = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    type: 'attribute',
-    attributeType: 'hitDice',
-    removed: { $ne: true },
-    inactive: { $ne: true },
-  }).fetch();
-  // Use a collator to do sorting in natural order
-  let collator = new Intl.Collator('en', {
-    numeric: true, sensitivity: 'base'
-  });
-  // Get the hit dice in decending order of hitDiceSize
-  let compare = (a, b) => collator.compare(b.hitDiceSize, a.hitDiceSize)
-  hitDice.sort(compare);
-  // Get the total number of hit dice that can be recovered this rest
-  let totalHd = hitDice.reduce((sum, hd) => sum + (hd.total || 0), 0);
-  let resetMultiplier = actionContext.creature.settings.hitDiceResetMultiplier || 0.5;
-  let recoverableHd = Math.max(Math.floor(totalHd * resetMultiplier), 1);
-  // recover each hit dice in turn until the recoverable amount is used up
-  let amountToRecover;
-  hitDice.forEach(hd => {
-    if (!recoverableHd) return;
-    amountToRecover = Math.min(recoverableHd, hd.damage ?? 0);
-    if (!amountToRecover) return;
-    recoverableHd -= amountToRecover;
-    damagePropertyWork({
-      prop: hd,
-      operation: 'increment',
-      value: -amountToRecover,
-      actionContext,
-      logFunction(increment) {
-        actionContext.addLog({
-          name: hd.name,
-          value: increment < 0 ? `Restored ${-increment} hit dice` : `Removed ${increment} hit dice`
-        });
-      }
-    });
-  });
-}
-
-export default restCreature;

app/imports/api/creature/creatures/methods/updateCreature.js

@@ -1,45 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-
-const updateCreature = new ValidatedMethod({
-  name: 'creatures.update',
-  validate({ _id, path }) {
-    if (!_id) return false;
-    // Allowed fields
-    let allowedFields = [
-      'name',
-      'alignment',
-      'gender',
-      'picture',
-      'avatarPicture',
-      'color',
-      'settings',
-    ];
-    if (!allowedFields.includes(path[0])) {
-      throw new Meteor.Error('Creatures.methods.update.denied',
-        'This field can\'t be updated using this method');
-    }
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, value }) {
-    let creature = Creatures.findOne(_id);
-    assertEditPermission(creature, this.userId);
-    if (value === undefined || value === null) {
-      Creatures.update(_id, {
-        $unset: { [path.join('.')]: 1 },
-      });
-    } else {
-      Creatures.update(_id, {
-        $set: { [path.join('.')]: value },
-      });
-    }
-  },
-});
-
-export default updateCreature;

app/imports/api/creature/experience/Experiences.js

@@ -1,186 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let Experiences = new Mongo.Collection('experiences');
-
-let ExperienceSchema = new SimpleSchema({
-  name: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  // The amount of XP this experience gives
-  xp: {
-    type: SimpleSchema.Integer,
-    optional: true,
-    min: 0,
-  },
-  // Setting levels instead of value grants whole levels
-  levels: {
-    type: SimpleSchema.Integer,
-    optional: true,
-    min: 0,
-    index: 1,
-  },
-  // The real-world date that it occured, usually sorted by date
-  date: {
-    type: Date,
-    autoValue: function () {
-      // If the date isn't set, set it to now
-      if (!this.isSet) {
-        return new Date();
-      }
-    },
-    index: 1,
-  },
-  creatureId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  },
-});
-
-Experiences.attachSchema(ExperienceSchema);
-
-const insertExperienceForCreature = function ({ experience, creatureId }) {
-  if (experience.xp) {
-    Creatures.update(creatureId, {
-      $inc: { 'denormalizedStats.xp': experience.xp },
-      $set: { dirty: true },
-    });
-  }
-  if (experience.levels) {
-    Creatures.update(creatureId, {
-      $inc: { 'denormalizedStats.milestoneLevels': experience.levels },
-      $set: { dirty: true },
-    });
-  }
-  experience.creatureId = creatureId;
-  let id = Experiences.insert(experience);
-  return id;
-};
-
-const insertExperience = new ValidatedMethod({
-  name: 'experiences.insert',
-  validate: new SimpleSchema({
-    experience: {
-      type: ExperienceSchema.omit('creatureId'),
-    },
-    creatureIds: {
-      type: Array,
-      max: 12,
-    },
-    'creatureIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ experience, creatureIds }) {
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('Experiences.methods.insert.denied',
-        'You need to be logged in to insert an experience');
-    }
-    let insertedIds = [];
-    creatureIds.forEach(creatureId => {
-      assertEditPermission(creatureId, userId);
-      let id = insertExperienceForCreature({ experience, creatureId, userId });
-      insertedIds.push(id);
-    });
-    return insertedIds;
-  },
-});
-
-const removeExperience = new ValidatedMethod({
-  name: 'experiences.remove',
-  validate: new SimpleSchema({
-    experienceId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ experienceId }) {
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('Experiences.methods.remove.denied',
-        'You need to be logged in to remove an experience');
-    }
-    let experience = Experiences.findOne(experienceId);
-    if (!experience) return;
-    let creatureId = experience.creatureId
-    assertEditPermission(creatureId, userId);
-    if (experience.xp) {
-      Creatures.update(creatureId, {
-        $inc: { 'denormalizedStats.xp': -experience.xp },
-        $set: { dirty: true },
-      });
-    }
-    if (experience.levels) {
-      Creatures.update(creatureId, {
-        $inc: { 'denormalizedStats.milestoneLevels': -experience.levels },
-        $set: { dirty: true },
-      });
-    }
-    experience.creatureId = creatureId;
-    let numRemoved = Experiences.remove(experienceId);
-    return numRemoved;
-  },
-});
-
-const recomputeExperiences = new ValidatedMethod({
-  name: 'experiences.recompute',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ creatureId }) {
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('Experiences.methods.recompute.denied',
-        'You need to be logged in to recompute a creature\'s experiences');
-    }
-    assertEditPermission(creatureId, userId);
-
-    let xp = 0;
-    let milestoneLevels = 0;
-    Experiences.find({
-      creatureId
-    }, {
-      fields: { xp: 1, levels: 1 }
-    }).forEach(experience => {
-      xp += experience.xp || 0;
-      milestoneLevels += experience.levels || 0;
-    });
-    Creatures.update(creatureId, {
-      $set: {
-        'denormalizedStats.xp': xp,
-        'denormalizedStats.milestoneLevels': milestoneLevels,
-        dirty: true,
-      }
-    });
-  },
-});
-
-export default Experiences;
-export { ExperienceSchema, insertExperience, insertExperienceForCreature, removeExperience, recomputeExperiences };

app/imports/api/creature/journal/JournalEntry.js

@@ -1,50 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let ExperienceSchema = new SimpleSchema({
-  title: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  // Potentially long description of the event
-  description: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.description,
-  },
-  // The real-world date that it occured
-  date: {
-    type: Date,
-    autoValue: function () {
-      // If the date isn't set, set it to now
-      if (!this.isSet) {
-        return new Date();
-      }
-    },
-  },
-  // The date in-world of this event
-  worldDate: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  // Tags to better find this entry later
-  tags: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.tagCount,
-  },
-  'tags.$': {
-    type: String,
-    max: STORAGE_LIMITS.tagLength,
-  },
-  // ID of the journal this entry belongs to
-  journalId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  }
-});
-
-export { ExperienceSchema };

app/imports/api/creature/log/CreatureLogs.js

@@ -1,218 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables.js';
-import LogContentSchema from '/imports/api/creature/log/LogContentSchema.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { parse, prettifyParseError } from '/imports/parser/parser.js';
-import resolve, { toString } from '/imports/parser/resolve.js';
-const PER_CREATURE_LOG_LIMIT = 100;
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-if (Meteor.isServer) {
-  var sendWebhookAsCreature = require('/imports/server/discord/sendWebhook.js').sendWebhookAsCreature;
-}
-
-let CreatureLogs = new Mongo.Collection('creatureLogs');
-
-let CreatureLogSchema = new SimpleSchema({
-  content: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.logContentCount,
-  },
-  'content.$': {
-    type: LogContentSchema,
-  },
-  // The real-world date that it occured, usually sorted by date
-  date: {
-    type: Date,
-    autoValue: function () {
-      // If the date isn't set, set it to now
-      if (!this.isSet) {
-        return new Date();
-      }
-    },
-    index: 1,
-  },
-  creatureId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  },
-  creatureName: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-});
-
-CreatureLogs.attachSchema(CreatureLogSchema);
-
-function removeOldLogs(creatureId) {
-  // Find the first log that is over the limit
-  let firstExpiredLog = CreatureLogs.find({
-    creatureId
-  }, {
-    sort: { date: -1 },
-    skip: PER_CREATURE_LOG_LIMIT,
-  });
-  if (!firstExpiredLog) return;
-  // Remove all logs older than the one over the limit
-  CreatureLogs.remove({
-    creatureId,
-    date: { $lte: firstExpiredLog.date },
-  });
-}
-
-function logToMessageData(log) {
-  let embed = {
-    fields: [],
-  };
-  log.content.forEach(field => {
-    if (!field.name) field.name = '\u200b';
-    if (!field.value) field.value = '\u200b';
-    embed.fields.push(field);
-  });
-  return { embeds: [embed] };
-}
-
-function logWebhook({ log, creature }) {
-  if (Meteor.isServer) {
-    sendWebhookAsCreature({
-      creature,
-      data: logToMessageData(log),
-    });
-  }
-}
-
-const insertCreatureLog = new ValidatedMethod({
-  name: 'creatureLogs.methods.insert',
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  validate: new SimpleSchema({
-    log: CreatureLogSchema.omit('date'),
-  }).validator(),
-  run({ log }) {
-    const creatureId = log.creatureId;
-    const creature = Creatures.findOne(creatureId, {
-      fields: {
-        readers: 1,
-        writers: 1,
-        owner: 1,
-        'settings.discordWebhook': 1,
-        name: 1,
-        avatarPicture: 1,
-      }
-    });
-    assertEditPermission(creature, this.userId);
-    // Build the new log
-    let id = insertCreatureLogWork({ log, creature, method: this })
-    return id;
-  },
-});
-
-export function insertCreatureLogWork({ log, creature, method }) {
-  // Build the new log
-  if (typeof log === 'string') {
-    log = { content: [{ value: log }] };
-  }
-  if (!log.content?.length) return;
-  log.date = new Date();
-  // Insert it
-  let id = CreatureLogs.insert(log);
-  if (Meteor.isServer) {
-    method?.unblock();
-    removeOldLogs(creature._id);
-    logWebhook({ log, creature });
-  }
-  return id;
-}
-
-
-function equalIgnoringWhitespace(a, b) {
-  if (typeof a !== 'string' || typeof b !== 'string') return a === b;
-  return a.replace(/\s/g, '') === b.replace(/\s/g, '');
-}
-
-const logRoll = new ValidatedMethod({
-  name: 'creatureLogs.methods.logForCreature',
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  validate: new SimpleSchema({
-    roll: {
-      type: String,
-    },
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  run({ roll, creatureId }) {
-    const creature = Creatures.findOne(creatureId, {
-      fields: {
-        readers: 1,
-        writers: 1,
-        owner: 1,
-        'settings.discordWebhook': 1,
-        name: 1,
-        avatarPicture: 1,
-      }
-    });
-    assertEditPermission(creature, this.userId);
-    const variables = CreatureVariables.findOne({ _creatureId: creatureId });
-    let logContent = []
-    let parsedResult = undefined;
-    try {
-      parsedResult = parse(roll);
-    } catch (e) {
-      let error = prettifyParseError(e);
-      logContent.push({ name: 'Parse Error', value: error });
-    }
-    if (parsedResult) try {
-      let {
-        result: compiled,
-        context
-      } = resolve('compile', parsedResult, variables);
-      const compiledString = toString(compiled);
-      if (!equalIgnoringWhitespace(compiledString, roll)) logContent.push({
-        value: roll
-      });
-      logContent.push({
-        value: compiledString
-      });
-      let { result: rolled } = resolve('roll', compiled, variables, context);
-      let rolledString = toString(rolled);
-      if (rolledString !== compiledString) logContent.push({
-        value: rolledString
-      });
-      let { result } = resolve('reduce', rolled, variables, context);
-      let resultString = toString(result);
-      if (resultString !== rolledString) logContent.push({
-        value: resultString
-      });
-    } catch (e) {
-      console.error(e);
-      logContent = [{ name: 'Calculation error' }];
-    }
-    const log = {
-      content: logContent,
-      creatureId,
-      date: new Date(),
-    };
-
-    let id = insertCreatureLogWork({ log, creature, method: this });
-
-    return id;
-  },
-});
-
-export default CreatureLogs;
-export { CreatureLogSchema, insertCreatureLog, logRoll, PER_CREATURE_LOG_LIMIT };

app/imports/api/creature/log/LogContentSchema.js

@@ -1,51 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
-import RollDetailsSchema from '/imports/api/properties/subSchemas/RollDetailsSchema.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let LogContentSchema = new SimpleSchema({
-  // The name of the field, included in discord webhook message
-  name: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  // The details of the field, included in discord webhook message
-  // Markdown support
-  value: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.summary,
-  },
-  // Inline with other content fields
-  inline: {
-    type: Boolean,
-    optional: true,
-  },
-  context: {
-    type: Object,
-    optional: true,
-  },
-  'context.errors':{
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.errorCount,
-  },
-  'context.errors.$': {
-    type: ErrorSchema,
-  },
-  'context.rolls': {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.rollCount,
-  },
-  'context.rolls.$': {
-    type: RollDetailsSchema,
-  },
-  'context.doubleRolls': {
-    type: Boolean,
-    optional: true,
-  },
-});
-
-export default LogContentSchema;

app/imports/api/creature/mixins/creaturePermissionMixin.js

@@ -1,52 +0,0 @@
-import {
-  assertEditPermission,
-  assertViewPermission,
-  assertOwnership,
-} from '/imports/api/creature/creatures/creaturePermissions.js';
-
-// Checks if the method has permission to run on the document. If the document
-// has a charId, that creature is checked, otherwise if it has an _id and the
-// collection is defined in the method options, that document is fetched to
-// determine its charId, otherwise a getCharId method can be defined to perform
-// a special search for the required creature
-//
-// Because this mixin injects the charId into argument objects that don't
-// already contain it, it should always come last in the mixin list, so that it
-// the outermost wrapper of the run function
-export default function creaturePermissionMixin(methodOptions){
-  let assertPermission;
-  if (methodOptions.permission === 'owner'){
-    assertPermission = assertOwnership;
-  } else if (methodOptions.permission === 'edit'){
-    assertPermission = assertEditPermission;
-  } else if (methodOptions.permission === 'view'){
-    assertPermission = assertViewPermission;
-  } else {
-    throw "`permission` missing in method options";
-  }
-
-  let getCharId;
-  if (methodOptions.getCharId){
-    getCharId = methodOptions.getCharId;
-  } else if (methodOptions.collection) {
-    getCharId = function({_id}){
-      return methodOptions.collection.findOne(_id, {
-        fields: {charId: 1}
-      }).charId;
-    };
-  } else {
-    getCharId = function(){
-      throw "`getCharId` or `collection` missing in method options," +
-      " or {charId} missing in call";
-    };
-  }
-
-  let runFunc = methodOptions.run;
-  methodOptions.run = function(doc, ...rest){
-    // Store the charId on the doc for other mixins if it had to be fetched
-    doc.charId = doc.charId || getCharId.apply(this, arguments);
-    assertPermission(doc.charId, this.userId);
-    return runFunc.call(this, doc, ...rest);
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/propagateInheritanceUpdateMixin.js

@@ -1,59 +0,0 @@
-import {
-  updateChildren,
-  updateDescendants,
-} from '/imports/api/parenting/parenting.js';
-import { inheritedFields } from '/imports/api/parenting/ChildSchema.js';
-import MONGO_OPERATORS from '/imports/constants/MONGO_OPERATORS.js';
-
-// This mixin can be safely applied to all update methods which are validated
-// with the updateSchemaMixin. It will propagate updates to fields which
-// are inherited and normalised on the parent or ancestor docs
-// It should have neglible performance impact for updates that aren't inherited
-function propagateInheritanceUpdate({_id, update}){
-  let childModifier = {};
-  let descendantModifier = {};
-  // For each operator
-  for (let operator of MONGO_OPERATORS){
-    // If the operator is in the update, for each field
-    if (update[operator]) for (let field in update[operator]){
-      // Get the top level field that was actually modified
-      const indexOfDot = field.indexOf('.');
-      let modifiedField;
-      if (indexOfDot !== -1) {
-        modifiedField = field.substring(0, indexOfDot);
-      } else {
-        modifiedField = field;
-      }
-      // If that field is updated and inherited
-      if (inheritedFields.has(modifiedField)){
-        // Perform the same update on the descendants
-        if (!childModifier[operator]) childModifier[operator] = {};
-        if (!descendantModifier[operator]) descendantModifier[operator] = {};
-        childModifier[operator][`parent.${field}`] = update[operator][field];
-        descendantModifier[operator][`ancestors.$.${field}`] = update[operator][field];
-      }
-    }
-  }
-
-  // Update the parent object of its children
-  updateChildren({
-    parentId: _id,
-    modifier: childModifier,
-  });
-
-  // Update the ancestors object of its descendants
-  updateDescendants({
-    ancestorId: _id,
-    modifier: descendantModifier,
-  });
-}
-
-export default function propagateInheritanceUpdateMixin(methodOptions){
-  let runFunc = methodOptions.run;
-  methodOptions.run = function({_id, update}){
-    const result = runFunc.apply(this, arguments);
-    propagateInheritanceUpdate({_id, update});
-    return result;
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/recomputeCreatureMixin.js

@@ -1,17 +0,0 @@
-import computeCreature from '/imports/api/engine/computeCreature.js';
-
-export default function recomputeCreatureMixin(methodOptions){
-  let runFunc = methodOptions.run;
-  methodOptions.run = function({charId}){
-    const result = runFunc.apply(this, arguments);
-    if (
-      methodOptions.skipRecompute &&
-      methodOptions.skipRecompute.apply(this, arguments)
-    ) {
-      return result;
-    }
-    computeCreature(charId);
-    return result;
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/setDocToLastMixin.js

@@ -1,27 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { setDocToLastOrder } from '/imports/api/parenting/order.js';
-
-export function setDocToLastMixin(methodOptions){
-  // Make sure the doc has a charId
-  // This mixin should come before simpleSchemaMixin so that it can extend the
-  // schema before it is turned into a validate function
-  if (methodOptions.validate){
-    throw new Meteor.Error(`setDocToLastMixin should come before simpleSchemaMixin`);
-  }
-  methodOptions.schema = new SimpleSchema({
-    charId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).extend(methodOptions.schema);
-  let collection = methodOptions.collection;
-  if (!collection){
-    throw new Meteor.Error("`collection` required in method options for setDocToLastMixin");
-  }
-  let runFunc = methodOptions.run;
-  methodOptions.run = function(doc){
-    setDocToLastOrder({collection, doc});
-    return runFunc.apply(this, arguments);
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/simpleSchemaMixin.js

@@ -1,51 +0,0 @@
-// Copied from https://github.com/sethjgore/meteor-simple-schema-mixin
-// and updated to simpl-schema npm package
-import SimpleSchema from 'simpl-schema';
-
-export default function simpleSchemaMixin(methodOptions) {
-  // If the user didn't give us a schema and they did give us a validate, assume
-  // that they are choosing to use the validate way of doing things in this call.
-  //  If they've built a wrapper around ValidateMethod that includes this mixin
-  // all the time, this could happen semi-"intentionally". There may be times they
-  // just don't want to use a schema and have specified a "validate" option. So
-  // returning the unchanged options instead of an error seems proper.
-  if ((typeof methodOptions.schema === 'undefined'
-      && typeof methodOptions.validate !== 'undefined')
-    || (typeof methodOptions.schema !== 'undefined' && methodOptions.schema === null
-      && typeof methodOptions.validate !== 'undefined' && methodOptions.validate !== null)) {
-    return methodOptions;
-  }
-
-  // If they truly gave us both... that just doesn't seem proper.
-  if (methodOptions.validate && methodOptions.validate !== null) {
-    throw new Meteor.Error(
-      'simpleSchemaMixin.options',
-      '"schema" and "validate" options cannot be used together');
-  }
-
-  // Note that setting them both null will make it through, defaulting to the
-  // schema = null behavior (enforce no args) instead of the validate = null
-  // behavior (do no validation).
-
-  const newOptions = methodOptions;
-  newOptions.schemaValidatorOptions =
-    newOptions.schemaValidatorOptions ||
-    { clean: true, filter: false };
-  let simpleSchema;
-  if (!newOptions.schema || newOptions.schema === null) {
-    // Allow simply leaving off both the schema and validate specifications
-    // or setting them to "null" as a shorthand. In this case, unlike
-    // the straight default validate or typical coder's call to validator,
-    // we will ENFORCE the Method be called without parameters because of
-    // the "filter: false" above.
-    simpleSchema = new SimpleSchema({});
-  } else if (newOptions.schema instanceof SimpleSchema) {
-    // In this one case, we can save ourselves the time to make a schema out
-    // of the schema.
-    simpleSchema = newOptions.schema;
-  } else {
-    simpleSchema = new SimpleSchema(newOptions.schema);
-  }
-  newOptions.validate = simpleSchema.validator(newOptions.schemaValidatorOptions);
-  return newOptions;
-};

app/imports/api/creature/mixins/updateSchemaMixin.js

@@ -1,67 +0,0 @@
-const argumentSchema = new SimpleSchema({
-  _id: SimpleSchema.RegEx.Id,
-  update: {
-    type: Object,
-    blackbox: true,
-  },
-});
-
-// Modified simpleSchemaMixin
-import SimpleSchema from 'simpl-schema';
-
-export default function updateSchemaMixin(methodOptions) {
-  // If the user didn't give us a schema and they did give us a validate, assume
-  // that they are choosing to use the validate way of doing things in this call.
-  if ((
-    typeof methodOptions.schema === 'undefined' &&
-    typeof methodOptions.validate !== 'undefined'
-  ) || (
-    typeof methodOptions.schema !== 'undefined' &&
-    methodOptions.schema === null &&
-    typeof methodOptions.validate !== 'undefined' &&
-    methodOptions.validate !== null
-  )) {
-    return methodOptions;
-  }
-
-  // If they truly gave us both... that just doesn't seem proper.
-  if (methodOptions.validate && methodOptions.validate !== null) {
-    throw new Meteor.Error(
-      'simpleSchemaMixin.options',
-      '"schema" and "validate" options cannot be used together');
-  }
-
-  // Note that setting them both null will make it through, defaulting to the
-  // schema = null behavior (enforce no args) instead of the validate = null
-  // behavior (do no validation).
-
-  // Apply default validator options if none are provided
-  methodOptions.schemaValidatorOptions =
-    methodOptions.schemaValidatorOptions ||
-    { clean: true, modifier: true };
-
-  // Make the update schema a SimpleSchema, if it isn't already
-  let updateSchema;
-  if (methodOptions.schema instanceof SimpleSchema) {
-    updateSchema = methodOptions.schema;
-  } else {
-    updateSchema = new SimpleSchema(methodOptions.schema);
-  }
-
-  // Set up the new validation
-  methodOptions.validate = function(args){
-    argumentSchema.validate(args);
-    updateSchema.validate(
-      {$set: args.update},
-      methodOptions.schemaValidatorOptions
-    );
-  };
-
-  // Give a default run function if one isn't supplied
-  if (!methodOptions.run){
-    methodOptions.run = function({_id, update}){
-      return methodOptions.collection.update(_id, {$set: update});
-    };
-  }
-  return methodOptions;
-}

app/imports/api/docs/Docs.js

@@ -1,324 +0,0 @@
-import { Meteor } from 'meteor/meteor';
-import { Mongo } from 'meteor/mongo';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
-import { storedIconsSchema } from '/imports/api/icons/Icons.js';
-import '/imports/api/library/methods/index.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-import { restore } from '/imports/api/parenting/softRemove.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import { getAncestry } from '/imports/api/parenting/parenting.js';
-
-const Docs = new Mongo.Collection('docs');
-
-const RefSchema = new SimpleSchema({
-  id: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1
-  },
-  collection: {
-    type: String,
-    max: STORAGE_LIMITS.collectionName,
-  },
-  urlName: {
-    type: String,
-    regEx: /[a-z]+(?:[a-z]|-)+/,
-    min: 2,
-    max: STORAGE_LIMITS.variableName,
-    optional: true,
-  },
-  name: {
-    type: String,
-    max: STORAGE_LIMITS.description,
-    optional: true,
-  },
-});
-
-let ChildSchema = new SimpleSchema({
-  order: {
-    type: Number,
-  },
-  parent: {
-    type: RefSchema,
-    optional: true,
-  },
-  ancestors: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.ancestorCount,
-  },
-  'ancestors.$': {
-    type: RefSchema,
-  },
-});
-
-let DocSchema = new SimpleSchema({
-  _id: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-  name: {
-    type: String,
-    max: STORAGE_LIMITS.description,
-  },
-  urlName: {
-    type: String,
-    regEx: /[a-z]+(?:[a-z]|-)+/,
-    min: 2,
-    max: STORAGE_LIMITS.variableName,
-  },
-  href: {
-    type: String,
-  },
-  description: {
-    type: String,
-    optional: true,
-  },
-  published: {
-    type: Boolean,
-    optional: true,
-  },
-  icon: {
-    type: storedIconsSchema,
-    optional: true,
-    max: STORAGE_LIMITS.icon,
-  },
-});
-
-let schema = new SimpleSchema({});
-schema.extend(DocSchema);
-schema.extend(ChildSchema);
-schema.extend(SoftRemovableSchema);
-Docs.attachSchema(schema);
-
-function assertDocsEditPermission(userId) {
-  if (!userId || typeof userId !== 'string') throw new Meteor.Error('No user id provided');
-  const user = Meteor.users.findOne(userId);
-  if (!user) throw new Meteor.Error('User does not exist');
-  if (!user?.roles?.includes?.('docsWriter')) throw ('Permission denied')
-}
-
-function getDocLink(doc, urlName) {
-  if (!urlName) urlName = doc.urlName;
-  const address = ['/docs'];
-  doc.ancestors?.forEach(a => {
-    address.push(a.urlName);
-  });
-  address.push(urlName);
-  return address.join('/');
-}
-
-function rebuildDocAncestors(docId) {
-  const newDoc = Docs.findOne(docId);
-  Docs.find({ 'ancestors.id': docId }).forEach(doc => {
-    doc.ancestors.forEach((a, i) => {
-      if (a.id === docId) {
-        Docs.update(doc._id, {
-          $set: {
-            [`ancestors.${i}`]: {
-              id: newDoc._id,
-              collection: 'docs',
-              urlName: newDoc.urlName,
-              name: newDoc.name,
-            }
-          }
-        });
-      }
-    });
-    doc = Docs.findOne(doc._id);
-    const newLink = getDocLink(doc);
-    if (doc.href !== newLink) {
-      Docs.update(doc._id, { $set: { href: newLink } })
-    }
-  });
-}
-
-// Add a means of seeding new servers with documentation
-if (Meteor.isClient) {
-  Docs.getJsonDocs = function () {
-    return JSON.stringify(Docs.find({}).fetch(), null, 2);
-  }
-} else if (Meteor.isServer) {
-  Meteor.startup(() => {
-    if (!Docs.findOne()) {
-      Assets.getText('docs/defaultDocs.json', (error, string) => {
-        const docs = JSON.parse(string)
-        docs.forEach(doc => Docs.insert(doc));
-      });
-    }
-  });
-}
-
-const insertDoc = new ValidatedMethod({
-  name: 'docs.insert',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ doc, parentRef }) {
-    delete doc._id;
-    assertDocsEditPermission(this.userId);
-    // get the new ancestry for the properties
-    if (parentRef) {
-      var { ancestors } = getAncestry({
-        parentRef,
-        inheritedFields: { name: 1, urlName: 1 },
-      });
-    }
-    doc.parent = parentRef;
-    doc.ancestors = ancestors;
-
-    const lastOrder = Docs.find({}, { sort: { order: -1 } }).fetch()[0]?.order || 0;
-    doc.order = lastOrder + 1;
-    doc.urlName = 'new-doc-' + (lastOrder + 1);
-
-    doc.href = getDocLink(doc);
-    if (Docs.findOne({ href: doc.href })) {
-      throw new Meteor.Error('Link collision', 'A document with the same URL already exists');
-    }
-
-    const docId = Docs.insert(doc);
-    reorderDocs({
-      collection: Docs,
-      ancestorId: 'root',
-    });
-    return docId;
-  },
-});
-
-const updateDoc = new ValidatedMethod({
-  name: 'docs.update',
-  validate({ _id, path }) {
-    if (!_id) return false;
-    // We cannot change these fields with a simple update
-    switch (path[0]) {
-      case '_is':
-        return false;
-    }
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, value }) {
-    assertDocsEditPermission(this.userId);
-    let pathString = path.join('.');
-    let modifier;
-    // unset empty values
-    if (value === null || value === undefined) {
-      modifier = { $unset: { [pathString]: 1 } };
-    } else {
-      modifier = { $set: { [pathString]: value } };
-    }
-    if (pathString === 'urlName') {
-      const doc = Docs.findOne(_id);
-      const newLink = getDocLink(doc, value);
-      if (Docs.findOne({ href: newLink })) {
-        throw new Meteor.Error('Link collision', 'A document with the same URL already exists');
-      }
-      modifier.$set = modifier.$set || {};
-      modifier.$set.href = newLink;
-      rebuildDocAncestors(_id);
-    }
-    const updates = Docs.update(_id, modifier);
-    if (pathString === 'name' || pathString === 'urlName') {
-      rebuildDocAncestors(_id);
-    }
-    reorderDocs({
-      collection: Docs,
-      ancestorId: 'root',
-    });
-    return updates;
-  },
-});
-
-const pushToDoc = new ValidatedMethod({
-  name: 'docs.push',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, value }) {
-    assertDocsEditPermission(this.userId);
-    return Docs.update(_id, {
-      $push: { [path.join('.')]: value },
-    });
-  }
-});
-
-const pullFromDoc = new ValidatedMethod({
-  name: 'docs.pull',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id, path, itemId }) {
-    assertDocsEditPermission(this.userId);
-    return Docs.update(_id, {
-      $pull: { [path.join('.')]: { _id: itemId } },
-    });
-  }
-});
-
-const softRemoveDoc = new ValidatedMethod({
-  name: 'docs.softRemove',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id }) {
-    assertDocsEditPermission(this.userId);
-    softRemove({ _id, collection: Docs });
-    reorderDocs({
-      collection: Docs,
-      ancestorId: 'root',
-    });
-  }
-});
-
-const restoreDoc = new ValidatedMethod({
-  name: 'docs.restore',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ _id }) {
-    assertDocsEditPermission(this.userId);
-    restore({ _id, collection: Docs });
-    reorderDocs({
-      collection: Docs,
-      ancestorId: 'root',
-    });
-  }
-});
-
-export {
-  DocSchema,
-  insertDoc,
-  updateDoc,
-  pushToDoc,
-  pullFromDoc,
-  softRemoveDoc,
-  restoreDoc,
-};
-
-export default Docs;

app/imports/api/engine/actions/ActionContext.js

@@ -1,78 +0,0 @@
-import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
-import {
-  getCreature, getVariables, getPropertiesOfType
-} from '/imports/api/engine/loadCreatures.js';
-import { groupBy, remove } from 'lodash';
-
-export default class ActionContext{
-  constructor(creatureId, targetIds = [], method) {
-    // Get the creature
-    this.creature = getCreature(creatureId)
-
-    if (!this.creature) {
-      throw new Meteor.Error('No Creature', `No creature could be found with id: ${creatureId}`)
-    }
-    // Create a log
-    this.log = CreatureLogSchema.clean({
-      creatureId: creatureId,
-      creatureName: this.creature.name,
-    });
-
-    // Get the variables of the acting creature
-    this.creature.variables = getVariables(creatureId);
-    delete this.creature.variables._id;
-    delete this.creature.variables._creatureId;
-    // Alias as scope
-    this.scope = this.creature.variables;
-
-    // Get the targets and their variables
-    this.targets = [];
-    targetIds.forEach(targetId => {
-      let target;
-      if (targetId === creatureId) {
-        target = this.creature;
-      } else {
-        target = getCreature(targetId);
-        target.variables = getVariables(targetId);
-        delete target.variables._id;
-        delete target.variables._creatureId;
-      }
-      this.targets.push(target);
-    });
-
-    // Store a reference to the method for inserting the log
-    this.method = method;
-
-    // Get triggers
-    this.triggers = getPropertiesOfType(creatureId, 'trigger');
-    // Remove deleted or inactive triggers
-    remove(this.triggers, trigger => trigger.removed || trigger.inactive);
-    // Sort triggers by order
-    this.triggers.sort((a, b) => a.order - b.order);
-    // Group the triggers into triggers.<event>.<timing> or
-    // triggers.doActionProperty.<propertyType>.<timing>
-    this.triggers = groupBy(this.triggers, 'event');
-    for (let event in this.triggers) {
-      if (event === 'doActionProperty') {
-        this.triggers[event] = groupBy(this.triggers[event], 'actionPropertyType');
-        for (let propertyType in this.triggers[event]) {
-          this.triggers[event][propertyType] = groupBy(this.triggers[event][propertyType], 'timing');
-        }
-      } else {
-        this.triggers[event] = groupBy(this.triggers[event], 'timing');
-      }
-    }
-  }
-  addLog(content) {
-    if (content.name || content.value){
-      this.log.content.push(content);
-    }
-  }
-  writeLog() {
-    insertCreatureLogWork({
-      log: this.log,
-      creature: this.creature,
-      method: this.method,
-    });
-  }
-}

app/imports/api/engine/actions/applyProperty.js

@@ -1,31 +0,0 @@
-import action from './applyPropertyByType/applyAction.js';
-import adjustment from './applyPropertyByType/applyAdjustment.js';
-import branch from './applyPropertyByType/applyBranch.js';
-import buff from './applyPropertyByType/applyBuff.js';
-import buffRemover from './applyPropertyByType/applyBuffRemover.js';
-import damage from './applyPropertyByType/applyDamage.js';
-import folder from './applyPropertyByType/applyFolder.js';
-import note from './applyPropertyByType/applyNote.js';
-import roll from './applyPropertyByType/applyRoll.js';
-import savingThrow from './applyPropertyByType/applySavingThrow.js';
-import toggle from './applyPropertyByType/applyToggle.js';
-
-const applyPropertyByType = {
-  action,
-  adjustment,
-  branch,
-  buff,
-  buffRemover,
-  damage,
-  folder,
-  note,
-  roll,
-  savingThrow,
-  spell: action,
-  toggle,
-};
-
-export default function applyProperty(node, actionContext, ...rest) {
-  actionContext.scope[`#${node.node.type}`] = node.node;
-  applyPropertyByType[node.node.type]?.(node, actionContext, ...rest);
-}

app/imports/api/engine/actions/applyPropertyByType/applyAction.js

@@ -1,306 +0,0 @@
-import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import rollDice from '/imports/parser/rollDice.js';
-import applyProperty from '../applyProperty.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { adjustQuantityWork } from '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import numberToSignedString from '/imports/api/utility/numberToSignedString.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import { resetProperties } from '/imports/api/creature/creatures/methods/restCreature.js';
-
-export default function applyAction(node, actionContext) {
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  if (prop.target === 'self') actionContext.targets = [actionContext.creature];
-  const targets = actionContext.targets;
-
-  // Log the name and summary
-  let content = { name: prop.name };
-  if (prop.summary?.text) {
-    recalculateInlineCalculations(prop.summary, actionContext);
-    content.value = prop.summary.value;
-  }
-  if (!prop.silent) actionContext.addLog(content);
-
-  // Spend the resources
-  const failed = spendResources(prop, actionContext);
-  if (failed) return;
-
-  const attack = prop.attackRoll || prop.attackRollBonus;
-
-  // Attack if there is an attack roll
-  if (attack && attack.calculation) {
-    if (targets.length) {
-      targets.forEach(target => {
-        applyAttackToTarget({ attack, target, actionContext });
-        // Apply the children, but only to the current target
-        actionContext.targets = [target];
-        applyChildren(node, actionContext);
-      });
-    } else {
-      applyAttackWithoutTarget({ attack, actionContext });
-      applyChildren(node, actionContext);
-    }
-  } else {
-    applyChildren(node, actionContext);
-  }
-  if (prop.actionType === 'event' && prop.variableName) {
-    resetProperties(actionContext.creature._id, prop.variableName, actionContext);
-  }
-}
-
-function applyAttackWithoutTarget({ attack, actionContext }) {
-  delete actionContext.scope['$attackHit'];
-  delete actionContext.scope['$attackMiss'];
-  delete actionContext.scope['$criticalHit'];
-  delete actionContext.scope['$criticalMiss'];
-  delete actionContext.scope['$attackRoll'];
-
-  recalculateCalculation(attack, actionContext);
-  const scope = actionContext.scope;
-  let {
-    resultPrefix,
-    result,
-    criticalHit,
-    criticalMiss,
-  } = rollAttack(attack, scope);
-  let name = criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit';
-  if (scope['$attackAdvantage'] === 1) {
-    name += ' (Advantage)';
-  } else if (scope['$attackAdvantage'] === -1) {
-    name += ' (Disadvantage)';
-  }
-  if (!criticalMiss) {
-    scope['$attackHit'] = { value: true }
-  }
-  if (!criticalHit) {
-    scope['$attackMiss'] = { value: true };
-  }
-
-  actionContext.addLog({
-    name,
-    value: `${resultPrefix}\n**${result}**`,
-    inline: true,
-  });
-}
-
-function applyAttackToTarget({ attack, target, actionContext }) {
-  const scope = actionContext.scope;
-  delete scope['$attackHit'];
-  delete scope['$attackMiss'];
-  delete scope['$criticalHit'];
-  delete scope['$criticalMiss'];
-  delete scope['$attackDiceRoll'];
-  delete scope['$attackRoll'];
-
-  recalculateCalculation(attack, actionContext);
-
-  let {
-    resultPrefix,
-    result,
-    criticalHit,
-    criticalMiss,
-  } = rollAttack(attack, scope);
-
-  if (target.variables.armor) {
-    const armor = target.variables.armor.value;
-
-    let name = criticalHit ? 'Critical Hit!' :
-      criticalMiss ? 'Critical Miss!' :
-        result > armor ? 'Hit!' : 'Miss!';
-    if (scope['$attackAdvantage'] === 1) {
-      name += ' (Advantage)';
-    } else if (scope['$attackAdvantage'] === -1) {
-      name += ' (Disadvantage)';
-    }
-
-    actionContext.addLog({
-      name,
-      value: `${resultPrefix}\n**${result}**`,
-      inline: true,
-    });
-    if (criticalMiss || result < armor) {
-      scope['$attackMiss'] = { value: true };
-    } else {
-      scope['$attackHit'] = { value: true };
-    }
-  } else {
-    actionContext.addLog({
-      name: 'Error',
-      value: 'Target has no `armor`',
-    });
-    actionContext.addLog({
-      name: criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit',
-      value: `${resultPrefix}\n**${result}**`,
-      inline: true,
-    });
-  }
-}
-
-function rollAttack(attack, scope) {
-  const rollModifierText = numberToSignedString(attack.value, true);
-  let value, resultPrefix;
-  if (scope['$attackAdvantage'] === 1) {
-    const [a, b] = rollDice(2, 20);
-    if (a >= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-    }
-  } else if (scope['$attackAdvantage'] === -1) {
-    const [a, b] = rollDice(2, 20);
-    if (a <= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-    }
-  } else {
-    value = rollDice(1, 20)[0];
-    resultPrefix = `1d20 [${value}] ${rollModifierText}`
-  }
-  scope['$attackDiceRoll'] = { value };
-  const result = value + attack.value;
-  scope['$attackRoll'] = { value: result };
-  const { criticalHit, criticalMiss } = applyCrits(value, scope);
-  return { resultPrefix, result, value, criticalHit, criticalMiss };
-}
-
-function applyCrits(value, scope) {
-  let criticalHitTarget = scope.criticalHitTarget?.value || 20;
-  let criticalHit = value >= criticalHitTarget;
-  let criticalMiss;
-  if (criticalHit) {
-    scope['$criticalHit'] = { value: true };
-  } else {
-    criticalMiss = value === 1;
-    if (criticalMiss) {
-      scope['$criticalMiss'] = { value: true };
-    }
-  }
-  return { criticalHit, criticalMiss };
-}
-
-function applyChildren(node, actionContext) {
-  applyNodeTriggers(node, 'after', actionContext);
-  node.children.forEach(child => applyProperty(child, actionContext));
-}
-
-function spendResources(prop, actionContext) {
-  // Check Uses
-  if (prop.usesLeft <= 0) {
-    if (!prop.silent) actionContext.addLog({
-      name: 'Error',
-      value: `${prop.name || 'action'} does not have enough uses left`,
-    });
-    return true;
-  }
-  // Resources
-  if (prop.insufficientResources) {
-    if (!prop.silent) actionContext.addLog({
-      name: 'Error',
-      value: 'This creature doesn\'t have sufficient resources to perform this action',
-    });
-    return true;
-  }
-  // Items
-  let itemQuantityAdjustments = [];
-  let spendLog = [];
-  let gainLog = [];
-  try {
-    prop.resources.itemsConsumed.forEach(itemConsumed => {
-      recalculateCalculation(itemConsumed.quantity, actionContext);
-      if (!itemConsumed.itemId) {
-        throw 'No ammo was selected for this prop';
-      }
-      let item = CreatureProperties.findOne(itemConsumed.itemId);
-      if (!item || item.ancestors[0].id !== prop.ancestors[0].id) {
-        throw 'The prop\'s ammo was not found on the creature';
-      }
-      if (!item.equipped) {
-        throw 'The selected ammo is not equipped';
-      }
-      if (
-        !itemConsumed.quantity.value ||
-        !isFinite(itemConsumed.quantity.value)
-      ) return;
-      itemQuantityAdjustments.push({
-        property: item,
-        operation: 'increment',
-        value: itemConsumed.quantity.value,
-      });
-      let logName = item.name;
-      if (itemConsumed.quantity.value > 1 || itemConsumed.quantity.value < -1) {
-        logName = item.plural || logName;
-      }
-      if (itemConsumed.quantity.value > 0) {
-        spendLog.push(logName + ': ' + itemConsumed.quantity.value);
-      } else if (itemConsumed.quantity.value < 0) {
-        gainLog.push(logName + ': ' + -itemConsumed.quantity.value);
-      }
-    });
-  } catch (e) {
-    actionContext.addLog({
-      name: 'Error',
-      value: e,
-    });
-    return true;
-  }
-  // No more errors should be thrown after this line
-  // Now that we have confirmed that there are no errors, do actual work
-  //Items
-  itemQuantityAdjustments.forEach(adjustQuantityWork);
-
-  // Use uses
-  if (prop.usesLeft) {
-    CreatureProperties.update(prop._id, {
-      $inc: { usesUsed: 1 }
-    }, {
-      selector: prop
-    });
-    if (!prop.silent) actionContext.addLog({
-      name: 'Uses left',
-      value: prop.usesLeft - 1,
-      inline: true,
-    });
-  }
-
-  // Damage stats
-  prop.resources.attributesConsumed.forEach(attConsumed => {
-    recalculateCalculation(attConsumed.quantity, actionContext);
-
-    if (!attConsumed.quantity?.value) return;
-    let stat = actionContext.scope[attConsumed.variableName];
-    if (!stat) {
-      spendLog.push(stat.name + ': ' + ' not found');
-      return;
-    }
-    damagePropertyWork({
-      prop: stat,
-      operation: 'increment',
-      value: attConsumed.quantity.value,
-      actionContext,
-    });
-    if (attConsumed.quantity.value > 0) {
-      spendLog.push(stat.name + ': ' + attConsumed.quantity.value);
-    } else if (attConsumed.quantity.value < 0) {
-      gainLog.push(stat.name + ': ' + -attConsumed.quantity.value);
-    }
-  });
-
-  // Log all the spending
-  if (gainLog.length && !prop.silent) actionContext.addLog({
-    name: 'Gained',
-    value: gainLog.join('\n'),
-    inline: true,
-  });
-  if (spendLog.length && !prop.silent) actionContext.addLog({
-    name: 'Spent',
-    value: spendLog.join('\n'),
-    inline: true,
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/applyAdjustment.js

@@ -1,61 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyAdjustment(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  const damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-
-  if (!prop.amount) {
-    return applyChildren(node, actionContext);
-  }
-
-  // Evaluate the amount
-  recalculateCalculation(prop.amount, actionContext);
-
-  const value = +prop.amount.value;
-  if (!isFinite(value)) {
-    return applyChildren(node, actionContext);
-  }
-
-  if (damageTargets?.length) {
-    damageTargets.forEach(target => {
-      let stat = target.variables[prop.stat];
-      if (!stat?.type) {
-        if (!prop.silent) actionContext.addLog({
-          name: 'Error',
-          value: `Could not apply attribute damage, creature does not have \`${prop.stat}\` set`
-        });
-        return applyChildren(node, actionContext);
-      }
-      damagePropertyWork({
-        prop: stat,
-        operation: prop.operation,
-        value,
-        actionContext,
-      });
-      if (!prop.silent) actionContext.addLog({
-        name: 'Attribute damage',
-        value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-        ` ${value}`,
-        inline: true,
-      });
-    });
-  } else {
-    if (!prop.silent) actionContext.addLog({
-      name: 'Attribute damage',
-      value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-      ` ${value}`,
-      inline: true,
-    });
-  }
-
-  return applyChildren(node, actionContext);
-}
-
-function applyChildren(node, actionContext){
-  applyNodeTriggers(node, 'after', actionContext);
-  node.children.forEach(child => applyProperty(child, actionContext));
-}

app/imports/api/engine/actions/applyPropertyByType/applyBranch.js

@@ -1,80 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import rollDice from '/imports/parser/rollDice.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyBranch(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const applyChildren = function(){
-    applyNodeTriggers(node, 'after', actionContext);
-    node.children.forEach(child => applyProperty(child, actionContext));
-  };
-  const scope = actionContext.scope;
-  const targets = actionContext.targets;
-  const prop = node.node;
-  switch(prop.branchType){
-    case 'if':
-      recalculateCalculation(prop.condition, actionContext);
-      if (prop.condition?.value) applyChildren();
-      break;
-    case 'index':
-      if (node.children.length){
-        recalculateCalculation(prop.condition, actionContext);
-        if (!isFinite(prop.condition?.value)) {
-          actionContext.addLog({
-            name: 'Branch Error',
-            value: 'Index did not resolve into a valid number'
-          });
-          break;
-        }
-        let index = Math.floor(prop.condition?.value);
-        if (index < 1) index = 1;
-        if (index > node.children.length) index = node.children.length;
-        applyNodeTriggers(node, 'after', actionContext);
-        applyProperty(node.children[index - 1], actionContext);
-      }
-      break;
-    case 'hit':
-      if (scope['$attackHit']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On hit**'});
-        applyChildren();
-      }
-      break;
-    case 'miss':
-      if (scope['$attackMiss']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On miss**'});
-        applyChildren();
-      }
-      break;
-    case 'failedSave':
-      if (scope['$saveFailed']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On failed save**'});
-        applyChildren();
-      }
-      break;
-    case 'successfulSave':
-      if (scope['$saveSucceeded']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On save**',});
-        applyChildren();
-      }
-      break;
-    case 'random':
-      if (node.children.length){
-        let index = rollDice(1, node.children.length)[0] - 1;
-        applyNodeTriggers(node, 'after', actionContext);
-        applyProperty(node.children[index], actionContext);
-      }
-      break;
-    case 'eachTarget':
-      if (targets.length) {
-        targets.forEach(target => {
-          applyNodeTriggers(node, 'after', actionContext);
-          actionContext.targets = [target]
-          node.children.forEach(child => applyProperty(child, actionContext));
-        });
-      } else {
-        applyChildren();
-      }
-      break;
-  }
-}

app/imports/api/engine/actions/applyPropertyByType/applyBuff.js

@@ -1,177 +0,0 @@
-import {
-  setLineageOfDocs,
-  renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import { setDocToLastOrder } from '/imports/api/parenting/order.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import computedSchemas from '/imports/api/properties/computedPropertySchemasIndex.js';
-import applyFnToKey from '/imports/api/engine/computation/utility/applyFnToKey.js';
-import { get } from 'lodash';
-import resolve, { map, toString } from '/imports/parser/resolve.js';
-import symbol from '/imports/parser/parseTree/symbol.js';
-import logErrors from './shared/logErrors.js';
-import { insertCreatureLog } from '/imports/api/creature/log/CreatureLogs.js';
-import cyrb53 from '/imports/api/engine/computation/utility/cyrb53.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
-
-export default function applyBuff(node, actionContext) {
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  let buffTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-
-  // Then copy the decendants of the buff to the targets
-  let propList = [prop];
-  function addChildrenToPropList(children, { skipCrystalize } = {}) {
-    children.forEach(child => {
-      if (skipCrystalize) child.node._skipCrystalize = true;
-      propList.push(child.node);
-      // recursively add the child's children, but don't crystalize nested buffs
-      addChildrenToPropList(child.children, {
-        skipCrystalize: skipCrystalize || child.node.type === 'buff'
-      });
-    });
-  }
-  addChildrenToPropList(node.children);
-  if (!prop.skipCrystalization) {
-    crystalizeVariables({ propList, actionContext });
-  }
-
-  let oldParent = {
-    id: prop.parent.id,
-    collection: prop.parent.collection,
-  };
-  buffTargets.forEach(target => {
-    // Apply the buff
-    copyNodeListToTarget(propList, target, oldParent);
-
-    //Log the buff
-    let logValue = prop.description?.value
-    if (prop.description?.text) {
-      recalculateInlineCalculations(prop.description, actionContext);
-      logValue = prop.description?.value;
-    }
-    if ((prop.name || prop.description?.value) && !prop.silent) {
-      if (target._id === actionContext.creature._id) {
-        // Targeting self
-        actionContext.addLog({
-          name: prop.name,
-          value: logValue,
-        });
-      } else {
-        // Targeting other
-        insertCreatureLog.call({
-          log: {
-            creatureId: target._id,
-            content: [{
-              name: prop.name,
-              value: logValue,
-            }],
-          }
-        });
-      }
-    }
-  });
-  applyNodeTriggers(node, 'after', actionContext);
-
-  // Don't apply the children of the buff, they get copied to the target instead
-}
-
-function copyNodeListToTarget(propList, target, oldParent) {
-  let ancestry = [{ collection: 'creatures', id: target._id }];
-  setLineageOfDocs({
-    docArray: propList,
-    newAncestry: ancestry,
-    oldParent,
-  });
-  renewDocIds({
-    docArray: propList,
-  });
-  setDocToLastOrder({
-    collection: CreatureProperties,
-    doc: propList[0],
-  });
-  CreatureProperties.batchInsert(propList);
-}
-
-/**
- * Replaces all variables with their resolved values
- * except variables of the form `$target.thing.total` become `thing.total`
- */
-function crystalizeVariables({ propList, actionContext }) {
-  propList.forEach(prop => {
-    if (prop._skipCrystalize) {
-      delete prop._skipCrystalize;
-      return;
-    }
-    // Iterate through all the calculations and crystalize them
-    computedSchemas[prop.type].computedFields().forEach(calcKey => {
-      applyFnToKey(prop, calcKey, (prop, key) => {
-        const calcObj = get(prop, key);
-        if (!calcObj?.parseNode) return;
-        calcObj.parseNode = map(calcObj.parseNode, node => {
-          // Skip nodes that aren't symbols or accessors
-          if (
-            node.parseType !== 'accessor' && node.parseType !== 'symbol'
-          ) return node;
-          // Handle variables
-          if (node.name === '$target') {
-            // strip $target
-            if (node.parseType === 'accessor') {
-              node.name = node.path.shift();
-              if (!node.path.length) {
-                return symbol.create({ name: node.name })
-              }
-            } else {
-              // Can't strip symbols
-              actionContext.addLog({
-                name: 'Error',
-                value: 'Variable `$target` should not be used without a property: $target.property',
-              });
-            }
-            return node;
-          } else {
-            // Resolve all other variables
-            const { result, context } = resolve('reduce', node, actionContext.scope);
-            logErrors(context.errors, actionContext);
-            return result;
-          }
-        });
-        calcObj.calculation = toString(calcObj.parseNode);
-        calcObj.hash = cyrb53(calcObj.calculation);
-      });
-    });
-    // For each key in the schema
-    computedSchemas[prop.type].inlineCalculationFields().forEach(calcKey => {
-      // That ends in .inlineCalculations
-      applyFnToKey(prop, calcKey, (prop, key) => {
-        const inlineCalcObj = get(prop, key);
-        if (!inlineCalcObj) return;
-
-        // If there is no text, skip
-        if (!inlineCalcObj.text) {
-          return;
-        }
-
-        // Replace all the existing calculations
-        let index = -1;
-        inlineCalcObj.text = inlineCalcObj.text.replace(INLINE_CALCULATION_REGEX, () => {
-          index += 1;
-          return `{${inlineCalcObj.inlineCalculations[index].calculation}}`;
-        });
-
-        // Set the value to the uncomputed string
-        inlineCalcObj.value = inlineCalcObj.text;
-
-        // Write a new hash
-        const inlineCalcHash = cyrb53(inlineCalcObj.text);
-        if (inlineCalcHash === inlineCalcObj.hash) {
-          // Skip if nothing changed
-          return;
-        }
-        inlineCalcObj.hash = inlineCalcHash;
-      });
-    });
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/applyBuffRemover.js

@@ -1,101 +0,0 @@
-import { findLast, difference, intersection, filter } from 'lodash';
-import applyProperty from '../applyProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import { getProperyAncestors, getPropertiesOfType } from '/imports/api/engine/loadCreatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-export default function applyBuffRemover(node, actionContext) {
-  // Apply triggers
-  applyNodeTriggers(node, 'before', actionContext);
-
-  const prop = node.node;
-
-  // Log Name
-  if (prop.name && !prop.silent){
-    actionContext.addLog({ name: prop.name });
-  }
-
-  // Remove buffs
-  if (prop.targetParentBuff) {
-    // Remove nearest ancestor buff
-    const ancestors = getProperyAncestors(actionContext.creature._id, prop._id);
-    const nearestBuff = findLast(ancestors, ancestor => ancestor.type === 'buff');
-    if (!nearestBuff) {
-      actionContext.addLog({
-        name: 'Error',
-        value: 'Buff remover does not have a parent buff to remove',
-      });
-      return;
-    }
-    removeBuff(nearestBuff, actionContext, prop);
-  } else {
-    // Get all the buffs targeted by tags
-    const allBuffs = getPropertiesOfType(actionContext.creature._id, 'buff');
-    const targetedBuffs = filter(allBuffs, buff => {
-      if (buff.inactive) return false;
-      if (buffRemoverMatchTags(prop, buff)) return true;
-    });
-    // Remove the buffs
-    if (prop.removeAll) {
-      // Remove all matching buffs
-      targetedBuffs.forEach(buff => {
-        removeBuff(buff, actionContext, prop);
-      });
-    } else {
-      // Sort in reverse order
-      targetedBuffs.sort((a, b) => b.order - a.order);
-      // Remove the one with the highest order
-      const buff = targetedBuffs[0];
-      if (buff) {
-        removeBuff(buff, actionContext, prop);
-      }
-    }
-  }
-
-  // Apply triggers
-  applyNodeTriggers(node, 'after', actionContext);
-  // Apply children
-  node.children.forEach(child => applyProperty(child, actionContext));
-}
-
-function removeBuff(buff, actionContext, prop) {
-  if (!prop.silent) actionContext.addLog({
-    name: 'Removed',
-    value: `${buff.name || 'Buff'}`
-  });
-  softRemove({ _id: buff._id, collection: CreatureProperties });
-}
-
-function buffRemoverMatchTags(buffRemover, prop) {
-  let matched = false;
-  const propTags = getEffectivePropTags(prop);
-  // Check the target tags
-  if (
-    !buffRemover.targetTags?.length ||
-    difference(buffRemover.targetTags, propTags).length === 0
-  ) {
-    matched = true;
-  }
-  // Check the extra tags
-  buffRemover.extraTags?.forEach(extra => {
-    if (extra.operation === 'OR') {
-      if (matched) return;
-      if (
-        !extra.tags.length ||
-        difference(extra.tags, propTags).length === 0
-      ) {
-        matched = true;
-      }
-    } else if (extra.operation === 'NOT') {
-      if (
-        extra.tags.length &&
-        intersection(extra.tags, propTags)
-      ) {
-        return false;
-      }
-    }
-  });
-  return matched;
-}

app/imports/api/engine/actions/applyPropertyByType/applyDamage.js

@@ -1,254 +0,0 @@
-import { some, intersection, difference, remove, includes } from 'lodash';
-import applyProperty from '../applyProperty.js';
-import { insertCreatureLog } from '/imports/api/creature/log/CreatureLogs.js';
-import resolve, { Context, toString } from '/imports/parser/resolve.js';
-import logErrors from './shared/logErrors.js';
-import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import {
-  getPropertiesOfType
-} from '/imports/api/engine/loadCreatures.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-export default function applyDamage(node, actionContext) {
-  applyNodeTriggers(node, 'before', actionContext);
-  const applyChildren = function () {
-    applyNodeTriggers(node, 'after', actionContext);
-    node.children.forEach(child => applyProperty(child, actionContext));
-  };
-
-  const prop = node.node;
-  const scope = actionContext.scope;
-
-  // Skip if there is no parse node to work with
-  if (!prop.amount?.parseNode) return;
-
-  // Choose target
-  let damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-  // Determine if the hit is critical
-  let criticalHit = scope['$criticalHit']?.value &&
-    prop.damageType !== 'healing' // Can't critically heal
-    ;
-  // Double the damage rolls if the hit is critical
-  let context = new Context({
-    options: { doubleRolls: criticalHit },
-  });
-
-  // Gather all the lines we need to log into an array
-  const logValue = [];
-  const logName = prop.damageType === 'healing' ? 'Healing' : 'Damage';
-
-  // roll the dice only and store that string
-  applyEffectsToCalculationParseNode(prop.amount, actionContext.log);
-  const { result: rolled } = resolve('roll', prop.amount.parseNode, scope, context);
-  if (rolled.parseType !== 'constant') {
-    logValue.push(toString(rolled));
-  }
-  logErrors(context.errors, actionContext);
-
-  // Reset the errors so we don't log the same errors twice
-  context.errors = [];
-
-  // Resolve the roll to a final value
-  const { result: reduced } = resolve('reduce', rolled, scope, context);
-  logErrors(context.errors, actionContext);
-
-  // Store the result
-  if (reduced.parseType === 'constant') {
-    prop.amount.value = reduced.value;
-  } else if (reduced.parseType === 'error') {
-    prop.amount.value = null;
-  } else {
-    prop.amount.value = toString(reduced);
-  }
-  let damage = +reduced.value;
-
-  // If we didn't end up with a constant of finite amount, give up
-  if (reduced?.parseType !== 'constant' || !isFinite(reduced.value)) {
-    return applyChildren();
-  }
-
-  // Round the damage to a whole number
-  damage = Math.floor(damage);
-
-  // Convert extra damage into the stored type
-  if (prop.damageType === 'extra' && scope['$lastDamageType']) {
-    prop.damageType = scope['$lastDamageType'];
-  }
-  // Store current damage type
-  if (prop.damageType !== 'healing') {
-    scope['$lastDamageType'] = prop.damageType;
-  }
-
-  // Memoise the damage suffix for the log
-  let suffix = (criticalHit ? ' critical ' : ' ') +
-    prop.damageType +
-    (prop.damageType !== 'healing' ? ' damage ' : '');
-
-  if (damageTargets && damageTargets.length) {
-    // Iterate through all the targets
-    damageTargets.forEach(target => {
-
-      // Apply weaknesses/resistances/immunities
-      damage = applyDamageMultipliers({
-        target,
-        damage,
-        damageProp: prop,
-        logValue
-      });
-
-      actionContext.target = [target];
-      // Deal the damage to the target
-      let damageDealt = dealDamage({
-        target,
-        damageType: prop.damageType,
-        amount: damage,
-        actionContext
-      });
-
-      // Log the damage done
-      if (target._id === actionContext.creature._id) {
-        // Target is same as self, log damage as such
-        logValue.push(`**${damageDealt}** ${suffix}  to self`);
-      } else {
-        logValue.push(`Dealt **${damageDealt}** ${suffix} ${target.name && ' to '}${target.name}`);
-        // Log the damage received on that creature's log as well
-        insertCreatureLog.call({
-          log: {
-            creatureId: target._id,
-            content: [{
-              name,
-              value: `Recieved **${damageDealt}** ${suffix}`,
-            }],
-          }
-        });
-      }
-    });
-  } else {
-    // There are no targets, just log the result
-    logValue.push(`**${damage}** ${suffix}`);
-  }
-  if (!prop.silent) actionContext.addLog({
-    name: logName,
-    value: logValue.join('\n'),
-    inline: true,
-  });
-  return applyChildren();
-}
-
-function applyDamageMultipliers({ target, damage, damageProp, logValue }) {
-  const damageType = damageProp?.damageType;
-  if (!damageType) return damage;
-
-  const multiplier = target?.variables?.[damageType];
-  if (!multiplier) return damage;
-
-  const damageTypeText = damageType == 'healing' ? 'healing' : `${damageType} damage`;
-
-  if (
-    multiplier.immunity &&
-    some(multiplier.immunities, multiplierAppliesTo(damageProp, 'immunity'))
-  ) {
-    logValue.push(`Immune to ${damageTypeText}`);
-    return 0;
-  } else {
-    if (
-      multiplier.resistance &&
-      some(multiplier.resistances, multiplierAppliesTo(damageProp, 'resistance'))
-    ) {
-      logValue.push(`Resistant to ${damageTypeText}`);
-      damage = Math.floor(damage / 2);
-    }
-    if (
-      multiplier.vulnerability &&
-      some(multiplier.vulnerabilities, multiplierAppliesTo(damageProp, 'vulnerability'))
-    ) {
-      logValue.push(`Vulnerable to ${damageTypeText}`);
-      damage = Math.floor(damage * 2);
-    }
-  }
-  return damage;
-}
-
-function multiplierAppliesTo(damageProp, multiplierType) {
-  return multiplier => {
-    // Apply the default 'ignore x' tags
-    const effectiveTags = getEffectivePropTags(damageProp);
-    if (includes(effectiveTags, `ignore ${multiplierType}`)) return false;
-
-    const hasRequiredTags = difference(
-      multiplier.includeTags, effectiveTags
-    ).length === 0;
-
-    const hasNoExcludedTags = intersection(
-      multiplier.excludeTags, effectiveTags
-    ).length === 0;
-
-    return hasRequiredTags && hasNoExcludedTags;
-  }
-}
-
-function dealDamage({ target, damageType, amount, actionContext }) {
-  // Get all the health bars and do damage to them
-  let healthBars = getPropertiesOfType(target._id, 'attribute');
-
-  // Keep only the healthbars that can take damage/healing
-  remove(healthBars, (bar) =>
-    bar.attributeType !== 'healthBar' ||
-    bar.inactive ||
-    bar.removed ||
-    bar.overridden ||
-    (amount >= 0 && bar.healthBarNoDamage) ||
-    (amount < 0 && bar.healthBarNoHealing)
-  );
-
-  // Sort healthbars by damage/healing order or tree order as a fallback
-  healthBars.sort((a, b) => {
-    let diff;
-    if (amount >= 0) {
-      diff = a.healthBarDamageOrder - b.healthBarDamageOrder;
-    } else {
-      diff = a.healthBarHealingOrder - b.healthBarHealingOrder;
-    }
-    if (Number.isFinite(diff)) {
-      return diff;
-    } else {
-      return a.order - b.order;
-    }
-  });
-
-  // Deal the damage to each healthbar in order until all damage is done
-  const totalDamage = amount;
-  let damageLeft = totalDamage;
-  if (damageType === 'healing') damageLeft = -totalDamage;
-  healthBars.forEach(healthBar => {
-    if (damageLeft === 0) return;
-    // Replace the healthbar by the one in the action context if we can
-    // The damagePropertyWork function bashes the prop with the damage
-    // So we can use the new value in later action properties
-    if (healthBar.variableName) {
-      const targetHealthBar = target.variables[healthBar.variableName];
-      if (targetHealthBar?._id === healthBar._id) {
-        healthBar = targetHealthBar;
-      }
-    }
-    // Do the damage
-    let damageAdded = damagePropertyWork({
-      prop: healthBar,
-      operation: 'increment',
-      value: damageLeft,
-      actionContext
-    });
-    damageLeft -= damageAdded;
-    // Prevent overflow
-    if (
-      damageType === 'healing' ?
-        healthBar.healthBarNoHealingOverflow :
-        healthBar.healthBarNoDamageOverflow
-    ) {
-      damageLeft = 0;
-    }
-  });
-  return totalDamage;
-}

app/imports/api/engine/actions/applyPropertyByType/applyFolder.js

@@ -1,11 +0,0 @@
-import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
-import applyProperty from '../applyProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyFolder(node, actionContext) {
-  // Apply triggers
-  applyNodeTriggers(node, 'before', actionContext);
-  applyNodeTriggers(node, 'after', actionContext);
-  // Apply children
-  node.children.forEach(child => applyProperty(child, actionContext));
-}

app/imports/api/engine/actions/applyPropertyByType/applyNote.js

@@ -1,27 +0,0 @@
-import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
-import applyProperty from '../applyProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyNote(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-
-  // Log Name, summary
-  let content = { name: prop.name };
-  if (prop.summary?.text){
-    recalculateInlineCalculations(prop.summary, actionContext);
-    content.value = prop.summary.value;
-  }
-  if (content.name || content.value){
-    actionContext.addLog(content);
-  }
-  // Log description
-  if (prop.description?.text){
-    recalculateInlineCalculations(prop.description, actionContext);
-    actionContext.addLog({value: prop.description.value});
-  }
-  // Apply triggers
-  applyNodeTriggers(node, 'after', actionContext);
-  // Apply children
-  node.children.forEach(child => applyProperty(child, actionContext));
-}

app/imports/api/engine/actions/applyPropertyByType/applyRoll.js

@@ -1,61 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import logErrors from './shared/logErrors.js';
-import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
-import resolve, { toString } from '/imports/parser/resolve.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyRoll(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-
-  const applyChildren = function(){
-    applyNodeTriggers(node, 'after', actionContext);
-    node.children.forEach(child => applyProperty(child, actionContext));
-  };
-
-  if (prop.roll?.calculation){
-    const logValue = [];
-
-    // roll the dice only and store that string
-    applyEffectsToCalculationParseNode(prop.roll, actionContext);
-    const {result: rolled, context} = resolve('roll', prop.roll.parseNode, actionContext.scope);
-    if (rolled.parseType !== 'constant'){
-      logValue.push(toString(rolled));
-    }
-    logErrors(context.errors, actionContext);
-
-    // Reset the errors so we don't log the same errors twice
-    context.errors = [];
-
-    // Resolve the roll to a final value
-    const {result: reduced} = resolve('reduce', rolled, actionContext.scope, context);
-    logErrors(context.errors, actionContext);
-
-    // Store the result
-    if (reduced.parseType === 'constant'){
-      prop.roll.value = reduced.value;
-    } else if (reduced.parseType === 'error'){
-      prop.roll.value = null;
-    } else {
-      prop.roll.value = toString(reduced);
-    }
-
-    // If we didn't end up with a constant of finite amount, give up
-    if (reduced?.parseType !== 'constant' || !isFinite(reduced.value)){
-      return applyChildren();
-    }
-    const value = reduced.value;
-
-    actionContext.scope[prop.variableName] = value;
-    logValue.push(`**${value}**`);
-
-    if (!prop.silent){
-      actionContext.addLog({
-        name: prop.name,
-        value: logValue.join('\n'),
-        inline: true,
-      });
-    }
-  }
-  return applyChildren();
-}

app/imports/api/engine/actions/applyPropertyByType/applySavingThrow.js

@@ -1,109 +0,0 @@
-import rollDice from '/imports/parser/rollDice.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import applyProperty from '../applyProperty.js';
-import numberToSignedString from '/imports/api/utility/numberToSignedString.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import { applyUnresolvedEffects } from '/imports/api/engine/actions/doCheck.js';
-
-export default function applySavingThrow(node, actionContext) {
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-
-  let saveTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-
-  recalculateCalculation(prop.dc, actionContext);
-
-  const dc = (prop.dc?.value);
-  if (!isFinite(dc)) {
-    actionContext.addLog({
-      name: 'Error',
-      value: 'Saving throw requires a DC',
-    });
-    return node.children.forEach(child => applyProperty(child, actionContext));
-  }
-  if (!prop.silent) actionContext.addLog({
-    name: prop.name,
-    value: `DC **${dc}**`,
-    inline: true,
-  });
-  const scope = actionContext.scope;
-
-  // If there are no save targets, apply all children as if the save both
-  // succeeeded and failed
-  if (!saveTargets?.length) {
-    scope['$saveFailed'] = { value: true };
-    scope['$saveSucceeded'] = { value: true };
-    applyNodeTriggers(node, 'after', actionContext);
-    return node.children.forEach(child => applyProperty(child, actionContext));
-  }
-
-  // Each target makes the saving throw
-  saveTargets.forEach(target => {
-    delete scope['$saveFailed'];
-    delete scope['$saveSucceeded'];
-    delete scope['$saveDiceRoll'];
-    delete scope['$saveRoll'];
-
-    const applyChildren = function () {
-      applyNodeTriggers(node, 'after', actionContext);
-      actionContext.targets = [target]
-      node.children.forEach(child => applyProperty(child, actionContext));
-    };
-
-    const save = target.variables[prop.stat];
-
-    if (!save) {
-      actionContext.addLog({
-        name: 'Saving throw error',
-        value: 'No saving throw found: ' + prop.stat,
-      });
-      return applyChildren();
-    }
-
-    let rollModifierText = numberToSignedString(save.value, true);
-    let rollModifier = save.value
-    const { effectBonus, effectString } = applyUnresolvedEffects(save, scope)
-    rollModifierText += effectString;
-    rollModifier += effectBonus;
-
-    let value, values, resultPrefix;
-    if (save.advantage === 1) {
-      const [a, b] = rollDice(2, 20);
-      if (a >= b) {
-        value = a;
-        resultPrefix = `Advantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-      } else {
-        value = b;
-        resultPrefix = `Advantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-      }
-    } else if (save.advantage === -1) {
-      const [a, b] = rollDice(2, 20);
-      if (a <= b) {
-        value = a;
-        resultPrefix = `Disadvantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-      } else {
-        value = b;
-        resultPrefix = `Disadvantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-      }
-    } else {
-      values = rollDice(1, 20);
-      value = values[0];
-      resultPrefix = `1d20 [ ${value} ] ${rollModifierText}`
-    }
-    scope['$saveDiceRoll'] = { value };
-    const result = value + rollModifier || 0;
-    scope['$saveRoll'] = { value: result };
-    const saveSuccess = result >= dc;
-    if (saveSuccess) {
-      scope['$saveSucceeded'] = { value: true };
-    } else {
-      scope['$saveFailed'] = { value: true };
-    }
-    if (!prop.silent) actionContext.addLog({
-      name: saveSuccess ? 'Successful save' : 'Failed save',
-      value: resultPrefix + '\n**' + result + '**',
-      inline: true,
-    });
-    return applyChildren();
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/applyToggle.js

@@ -1,13 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyToggle(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  recalculateCalculation(prop.condition, actionContext);
-  if (prop.condition?.value) {
-    applyNodeTriggers(node, 'after', actionContext);
-    return node.children.forEach(child => applyProperty(child, actionContext));
-  }
-}

app/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js

@@ -1,24 +0,0 @@
-import operator from '/imports/parser/parseTree/operator.js';
-import { parse } from '/imports/parser/parser.js';
-import logErrors from './logErrors.js';
-
-export default function applyEffectsToCalculationParseNode(calcObj, actionContext){
-  if (!calcObj.effects) return;
-  calcObj.effects.forEach(effect => {
-    if (effect.operation !== 'add') return;
-    if (!effect.amount) return;
-    if (effect.amount.value === null) return;
-    let effectParseNode;
-    try {
-      effectParseNode = parse(effect.amount.value.toString());
-      calcObj.parseNode = operator.create({
-        left: calcObj.parseNode,
-        right: effectParseNode,
-        operator: '+',
-        fn: 'add'
-      });
-    } catch (e){
-      logErrors([e], actionContext)
-    }
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/shared/logErrors.js

@@ -1,7 +0,0 @@
-export default function logErrors(errors, actionContext){
-  errors?.forEach(error => {
-    if (error.type !== 'info'){
-      actionContext.addLog({name: 'Error', value: error.message});
-    }
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation.js

@@ -1,11 +0,0 @@
-import evaluateCalculation from '/imports/api/engine/computation/utility/evaluateCalculation.js';
-import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
-import logErrors from './logErrors.js';
-
-export default function recalculateCalculation(calc, actionContext, context){
-  if (!calc?.parseNode) return;
-  calc._parseLevel = 'reduce';
-  applyEffectsToCalculationParseNode(calc, actionContext);
-  evaluateCalculation(calc, actionContext.scope, context);
-  logErrors(calc.errors, actionContext);
-}

app/imports/api/engine/actions/applyPropertyByType/shared/recalculateInlineCalculations.js

@@ -1,13 +0,0 @@
-import embedInlineCalculations from '/imports/api/engine/computation/utility/embedInlineCalculations.js';
-import recalculateCalculation from './recalculateCalculation.js'
-
-export default function recalculateInlineCalculations(inlineCalcObj, actionContext){
-  // Skip if there are no calculations
-  if (!inlineCalcObj?.inlineCalculations?.length) return;
-  // Recalculate each calculation with the current scope
-  inlineCalcObj.inlineCalculations.forEach(calc => {
-    recalculateCalculation(calc, actionContext);
-  });
-  // Embed the new calculated values
-  embedInlineCalculations(inlineCalcObj);
-}

app/imports/api/engine/actions/applyTriggers.js

@@ -1,111 +0,0 @@
-import recalculateCalculation from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation.js';
-import recalculateInlineCalculations from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateInlineCalculations.js';
-import { getPropertyDecendants } from '/imports/api/engine/loadCreatures.js';
-import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
-import applyProperty from '/imports/api/engine/actions/applyProperty.js';
-import { difference, intersection } from 'lodash';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-export function applyNodeTriggers(node, timing, actionContext) {
-  const prop = node.node;
-  const type = prop.type;
-  const triggers = actionContext.triggers?.doActionProperty?.[type]?.[timing];
-  if (triggers) {
-    triggers.forEach(trigger => {
-      applyTrigger(trigger, prop, actionContext);
-    });
-  }
-}
-
-export function applyTriggers(triggers = [], prop, actionContext) {
-  // Apply the triggers
-  triggers.forEach(trigger => {
-    applyTrigger(trigger, prop, actionContext)
-  });
-}
-
-export function applyTrigger(trigger, prop, actionContext) {
-  // If there is a prop we are applying the trigger from,
-  // don't fire if the tags don't match
-  if (prop && !triggerMatchTags(trigger, prop)) {
-    return;
-  }
-
-  // Prevent trigger from firing if it's inactive
-  if (trigger.inactive) {
-    return;
-  }
-  
-  // Prevent triggers from firing if their condition is false
-  if (trigger.condition?.parseNode) {
-    recalculateCalculation(trigger.condition, actionContext);
-    if (!trigger.condition.value) return;
-  }
-
-  // Prevent triggers from firing themselves in a loop
-  if (trigger.firing) {
-    /*
-    log.content.push({
-      name: trigger.name || 'Trigger',
-      value: 'Trigger can\'t fire itself',
-      inline: true,
-    });
-    */
-    return;
-  }
-  trigger.firing = true;
-
-  // Fire the trigger
-  const content = {
-    name: trigger.name || 'Trigger',
-    value: trigger.description,
-    inline: false,
-  }
-  if (trigger.description?.text){
-    recalculateInlineCalculations(trigger.description, actionContext);
-    content.value = trigger.description.value;
-  }
-  if(!trigger.silent) actionContext.addLog(content);
-
-  // Get all the trigger's properties and apply them
-  const properties = getPropertyDecendants(actionContext.creature._id, trigger._id);
-  properties.sort((a, b) => a.order - b.order);
-  const propertyForest = nodeArrayToTree(properties);
-  propertyForest.forEach(node => {
-    applyProperty(node, actionContext);
-  });
-
-  trigger.firing = false;
-}
-
-function triggerMatchTags(trigger, prop) {
-  let matched = false;
-  const propTags = getEffectivePropTags(prop);
-  // Check the target tags
-  if (
-    !trigger.targetTags?.length ||
-    difference(trigger.targetTags, propTags).length === 0
-  ) {
-    matched = true;
-  }
-  // Check the extra tags
-  trigger.extraTags?.forEach(extra => {
-    if (extra.operation === 'OR') {
-      if (matched) return;
-      if (
-        !extra.tags.length ||
-        difference(extra.tags, propTags).length === 0
-      ) {
-        matched = true;
-      }
-    } else if (extra.operation === 'NOT') {
-      if (
-        extra.tags.length &&
-        intersection(extra.tags, propTags)
-      ) {
-        return false;
-      }
-    }
-  });
-  return matched;
-}

app/imports/api/engine/actions/doAction.js

@@ -1,100 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
-import {
-  getProperyAncestors, getPropertyDecendants
-} from '/imports/api/engine/loadCreatures.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import applyProperty from './applyProperty.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const doAction = new ValidatedMethod({
-  name: 'creatureProperties.doAction',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    targetIds: {
-      type: Array,
-      defaultValue: [],
-      maxCount: 20,
-      optional: true,
-    },
-    'targetIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    scope: {
-      type: Object,
-      blackbox: true,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ actionId, targetIds = [], scope }) {
-    // Get action context
-    let action = CreatureProperties.findOne(actionId);
-    const creatureId = action.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, targetIds, this);
-
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-    actionContext.targets.forEach(target => {
-      assertEditPermission(target, this.userId);
-    });
-
-    const ancestors = getProperyAncestors(creatureId, action._id);
-    ancestors.sort((a, b) => a.order - b.order);
-
-    const properties = getPropertyDecendants(creatureId, action._id);
-    properties.push(action);
-    properties.sort((a, b) => a.order - b.order);
-
-    // Do the action
-    doActionWork({ properties, ancestors, actionContext, methodScope: scope });
-
-    // Recompute all involved creatures
-    Creatures.update({
-      _id: { $in: [creatureId, ...targetIds] }
-    }, {
-      $set: { dirty: true },
-    });
-  },
-});
-
-export default doAction;
-
-export function doActionWork({
-  properties, ancestors, actionContext, methodScope = {},
-}) {
-  // get the docs
-  const ancestorScope = getAncestorScope(ancestors);
-  const propertyForest = nodeArrayToTree(properties);
-  if (propertyForest.length !== 1) {
-    throw new Meteor.Error(`The action has ${propertyForest.length} top level properties, expected 1`);
-  }
-
-  // Include the ancestry and method scope in the context scope
-  Object.assign(actionContext.scope, ancestorScope, methodScope);
-
-  // Apply the top level property, it is responsible for applying its children
-  // recursively
-  applyProperty(propertyForest[0], actionContext);
-
-  // Insert the log
-  actionContext.writeLog();
-}
-
-// Assumes ancestors are in tree order already
-function getAncestorScope(ancestors) {
-  let scope = {};
-  ancestors.forEach(prop => {
-    scope[`#${prop.type}`] = prop;
-  });
-  return scope;
-}

app/imports/api/engine/actions/doAction.test.js

@@ -1,53 +0,0 @@
-import '/imports/api/simpleSchemaConfig.js';
-//import testTypes from './testTypes/index.js';
-import { doActionWork } from './doAction.js';
-import { CreatureLogSchema } from '/imports/api/creature/log/CreatureLogs.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-function cleanProp(prop){
-  let schema = CreatureProperties.simpleSchema(prop);
-  return schema.clean(prop);
-}
-
-function cleanCreature(creature){
-  let schema = Creatures.simpleSchema(creature);
-  return schema.clean(creature);
-}
-
-// Fake ActionContext to test actions with
-const creatureId = 'actionTestCreatureId';
-const creatureName = 'Action Test Creature';
-const testActionContext = {
-  creature: cleanCreature({
-    _id: creatureId,
-  }),
-  log: CreatureLogSchema.clean({
-    creatureId: creatureId,
-    creatureName: creatureName,
-  }),
-  scope: {},
-  addLog(content) {
-    if (content.name || content.value){
-      this.log.content.push(content);
-    }
-  },
-  writeLog: () => { },
-}
-
-const action = cleanProp({
-  type: 'action',
-});
-const actionAncestors = [];
-
-describe('Do Action', function(){
-  it('Does an empty action', function(){
-    doActionWork({
-      properties: [action],
-      ancestors: actionAncestors,
-      actionContext: testActionContext,
-      methodScope: {},
-    });
-  });
-  //testTypes.forEach(test => it(test.text, test.fn));
-});

app/imports/api/engine/actions/doCastSpell.js

@@ -1,136 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {
-  getProperyAncestors, getPropertyDecendants
-} from '/imports/api/engine/loadCreatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { doActionWork } from '/imports/api/engine/actions/doAction.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const doAction = new ValidatedMethod({
-  name: 'creatureProperties.doCastSpell',
-  validate: new SimpleSchema({
-    spellId: SimpleSchema.RegEx.Id,
-    slotId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-    ritual: {
-      type: Boolean,
-      optional: true,
-    },
-    targetIds: {
-      type: Array,
-      defaultValue: [],
-      maxCount: 20,
-      optional: true,
-    },
-    'targetIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    scope: {
-      type: Object,
-      blackbox: true,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ spellId, slotId, ritual, targetIds = [], scope = {} }) {
-    // Get action context
-    let spell = CreatureProperties.findOne(spellId);
-    const creatureId = spell.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, targetIds, this);
-
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-    actionContext.targets.forEach(target => {
-      assertEditPermission(target, this.userId);
-    });
-
-    const ancestors = getProperyAncestors(creatureId, spell._id);
-    ancestors.sort((a, b) => a.order - b.order);
-
-    const properties = getPropertyDecendants(creatureId, spell._id);
-    properties.push(spell);
-    properties.sort((a, b) => a.order - b.order);
-
-    // Spend the appropriate slot
-    let slotLevel = spell.level || 0;
-    let slot;
-
-    // If a spell requires a slot, make sure a slot is spent
-    if (spell.level && !spell.castWithoutSpellSlots && !(ritual && spell.ritual)) {
-      slot = CreatureProperties.findOne(slotId);
-      if (!slot) {
-        throw new Meteor.Error('No slot',
-          'Slot not found to cast spell');
-      }
-      if (!slot.value) {
-        throw new Meteor.Error('No slot',
-          'Slot depleted');
-      }
-      if (slot.attributeType !== 'spellSlot') {
-        throw new Meteor.Error('Not a slot',
-          'The given property is not a valid spell slot');
-      }
-      if (!slot.spellSlotLevel?.value) {
-        throw new Meteor.Error('No slot level',
-          'Slot does not have a spell slot level');
-      }
-      if (slot.spellSlotLevel.value < spell.level) {
-        throw new Meteor.Error('Slot too small',
-          'Slot is not large enough to cast spell');
-      }
-      slotLevel = slot.spellSlotLevel.value;
-      damagePropertyWork({
-        prop: slot,
-        operation: 'increment',
-        value: 1,
-        actionContext,
-      });
-    }
-
-    // Post the slot level spent to the log
-    if (slot?.spellSlotLevel?.value) {
-      actionContext.addLog({
-        name: `Casting using a level ${slotLevel} spell slot`
-      });
-    } else if (slotLevel) {
-      if (ritual) {
-        actionContext.addLog({
-          name: `Ritual casting at level ${slotLevel}`
-        });
-      } else {
-        actionContext.addLog({
-          name: `Casting at level ${slotLevel}`
-        });
-      }
-    }
-
-    actionContext.scope['slotLevel'] = slotLevel;
-
-    // Do the action
-    doActionWork({
-      properties, ancestors, actionContext, methodScope: scope,
-    });
-
-    // Force the characters involved to recalculate
-    Creatures.update({
-      _id: { $in: [creatureId, ...targetIds] }
-    }, {
-      $set: { dirty: true },
-    });
-  },
-});
-
-export default doAction;

app/imports/api/engine/actions/doCheck.js

@@ -1,135 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import rollDice from '/imports/parser/rollDice.js';
-import numberToSignedString from '/imports/api/utility/numberToSignedString.js';
-import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-import evaluateCalculation from '/imports/api/engine/computation/utility/evaluateCalculation.js';
-
-const doCheck = new ValidatedMethod({
-  name: 'creatureProperties.doCheck',
-  validate: new SimpleSchema({
-    propId: SimpleSchema.RegEx.Id,
-    scope: {
-      type: Object,
-      blackbox: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ propId, scope }) {
-    const prop = CreatureProperties.findOne(propId);
-    const creatureId = prop.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-    Object.assign(actionContext.scope, scope);
-    actionContext.scope[`#${prop.type}`] = prop;
-
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-    // Do the check
-    doCheckWork({ prop, actionContext });
-  },
-});
-
-export default doCheck;
-
-export function doCheckWork({ prop, actionContext }) {
-
-  applyTriggers(actionContext.triggers.check?.before, prop, actionContext);
-  rollCheck(prop, actionContext);
-  applyTriggers(actionContext.triggers.check?.after, prop, actionContext);
-
-  // Insert the log
-  actionContext.writeLog();
-}
-
-function rollCheck(prop, actionContext) {
-  const scope = actionContext.scope;
-  // get the modifier for the roll
-  let rollModifier;
-  let logName = `${prop.name} check`;
-  if (prop.type === 'skill') {
-    rollModifier = prop.value;
-    if (prop.skillType === 'save') {
-      if (prop.name.match(/save/i)) {
-        logName = prop.name;
-      } else {
-        logName = prop.name ? `${prop.name} save` : 'Saving Throw';
-      }
-    }
-  } else if (prop.type === 'attribute') {
-    if (prop.attributeType === 'ability') {
-      rollModifier = prop.modifier;
-    } else {
-      rollModifier = prop.value;
-    }
-  } else {
-    throw (`${prop.type} not supported for checks`);
-  }
-
-  let rollModifierText = numberToSignedString(rollModifier, true);
-
-  const { effectBonus, effectString } = applyUnresolvedEffects(prop, scope)
-  rollModifierText += effectString;
-  rollModifier += effectBonus;
-
-  let value, values, resultPrefix;
-  if (scope['$checkAdvantage'] === 1) {
-    logName += ' (Advantage)';
-    const [a, b] = rollDice(2, 20);
-    if (a >= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText} = `;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
-    }
-  } else if (scope['$checkAdvantage'] === -1) {
-    logName += ' (Disadvantage)';
-    const [a, b] = rollDice(2, 20);
-    if (a <= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText} = `;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
-    }
-  } else {
-    values = rollDice(1, 20);
-    value = values[0];
-    resultPrefix = `1d20 [ ${value} ] ${rollModifierText} = `
-  }
-  const result = (value + rollModifier) || 0;
-  scope['$checkDiceRoll'] = value;
-  scope['$checkRoll'] = result;
-  scope['$checkModifier'] = rollModifier;
-  actionContext.addLog({
-    name: logName,
-    value: `${resultPrefix} **${result}**`,
-  });
-}
-
-export function applyUnresolvedEffects(prop, scope) {
-  let effectBonus = 0;
-  let effectString = '';
-  if (!prop.effects) {
-    return { effectBonus, effectString };
-  }
-  prop.effects.forEach(effect => {
-    if (!effect.amount?.parseNode) return;
-    if (effect.operation !== 'add') return;
-    effect.amount._parseLevel = 'reduce';
-    evaluateCalculation(effect.amount, scope);
-    if (typeof effect.amount?.value !== 'number') return;
-    effectBonus += effect.amount.value;
-    effectString += ` ${effect.amount.value < 0 ? '-' : '+'} [${effect.amount.calculation}] ${Math.abs(effect.amount.value)}`
-  });
-  return { effectBonus, effectString };
-}

app/imports/api/engine/actions/index.js

@@ -1,2 +0,0 @@
-import './doCastSpell.js';
-import './doCheck.js';

app/imports/api/engine/computation/CreatureComputation.ts

@@ -1,55 +0,0 @@
-import { EJSON } from 'meteor/ejson';
-import createGraph, { Graph } from 'ngraph.graph';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-interface CreatureProperty {
-  _id: string;
-  type: string;
-}
-
-export default class CreatureComputation {
-  originalPropsById: object;
-  propsById: object;
-  propsWithTag: object;
-  scope: object;
-  props: Array<CreatureProperty>;
-  dependencyGraph: Graph;
-  errors: Array<object>;
-  creature: object;
-  variables: object;
-
-  constructor(properties: Array<CreatureProperty>, creature: object, variables: object) {
-    // Set up fields
-    this.originalPropsById = {};
-    this.propsById = {};
-    this.propsWithTag = {};
-    this.scope = {};
-    this.props = properties;
-    this.dependencyGraph = createGraph();
-    this.errors = [];
-    this.creature = creature;
-    this.variables = variables;
-
-    // Store properties for easy access later
-    properties.forEach(prop => {
-      // Store a copy of the unmodified prop
-      // EJSON clone is ~4x faster than lodash cloneDeep for EJSONable objects
-      this.originalPropsById[prop._id] = EJSON.clone(prop);
-      // Store by id
-      this.propsById[prop._id] = prop;
-
-      // Store sets of ids in each tag
-      getEffectivePropTags(prop).forEach(tag => {
-        if (!tag) return;
-        if (this.propsWithTag[tag]) {
-          this.propsWithTag[tag].push(prop._id);
-        } else {
-          this.propsWithTag[tag] = [prop._id];
-        }
-      });
-
-      // Store the prop in the dependency graph
-      this.dependencyGraph.addNode(prop._id, prop);
-    });
-  }
-}

app/imports/api/engine/computation/buildComputation/computeInactiveStatus.js

@@ -1,43 +0,0 @@
-import walkDown from '/imports/api/engine/computation/utility/walkdown.js';
-
-export default function computeInactiveStatus(node){
-  const prop = node.node;
-  if (!isActive(prop)){
-    // Mark prop inactive due to self
-    prop.inactive = true;
-    prop.deactivatedBySelf = true;
-  }
-  if(!childrenActive(prop)){
-    // Mark children as inactive due to ancestor
-    walkDown(node.children, child => {
-      child.node.inactive = true;
-      child.node.deactivatedByAncestor = true;
-    });
-  }
-}
-
-function isActive(prop){
-  if (prop.disabled) return false;
-  switch (prop.type){
-    // Unprepared spells are inactive
-    case 'spell': return !!prop.prepared || !!prop.alwaysPrepared;
-    default: return true;
-  }
-}
-
-function childrenActive(prop){
-  // Children of disabled properties are always inactive
-  if (prop.disabled) return false;
-  switch (prop.type){
-    // Only equipped items with non-zero quantity have active children
-    case 'item': return !!prop.equipped && prop.quantity !== 0;
-    // The children of actions, spells, and triggers are always inactive
-    case 'action': return false;
-    case 'spell': return false;
-    case 'trigger': return false;
-    // The children of notes are always inactive
-    case 'note': return false;
-    // Other children are active
-    default: return true;
-  }
-}

app/imports/api/engine/computation/buildComputation/computeSlotQuantityFilled.js

@@ -1,21 +0,0 @@
-/**
- * Only computes `totalFilled`, need to compute `quantityExpected.value`
- * before `spacesLeft` can be computed
- */
-export default function computeSlotQuantityFilled(node, dependencyGraph){
-  let slot = node.node;
-  if (slot.type !== 'propertySlot') return;
-  slot.totalFilled = 0;
-  node.children.forEach(child => {
-    let childProp = child.node;
-    dependencyGraph.addLink(slot._id, childProp._id, 'slotFill');
-    if (
-      childProp.type === 'slotFiller' &&
-      Number.isFinite(childProp.slotQuantityFilled)
-    ){
-      slot.totalFilled += childProp.slotQuantityFilled;
-    } else {
-      slot.totalFilled++;
-    }
-  });
-}

app/imports/api/engine/computation/buildComputation/computeToggleDependencies.js

@@ -1,17 +0,0 @@
-import walkDown from '/imports/api/engine/computation/utility/walkdown.js';
-
-export default function computeToggleDependencies(node, dependencyGraph){
-  const prop = node.node;
-  // Only for toggles that aren't inactive and aren't set to enabled or disabled
-  if (
-    prop.inactive ||
-    prop.type !== 'toggle' ||
-    prop.disabled ||
-    prop.enabled
-  ) return;
-  walkDown(node.children, child => {
-    // The child nodes depend on the toggle condition compuation
-    child.node._computationDetails.toggleAncestors.push(prop);
-    dependencyGraph.addLink(child.node._id, prop._id, 'toggle');
-  });
-}

app/imports/api/engine/computation/buildComputation/linkCalculationDependencies.js

@@ -1,52 +0,0 @@
-import findAncestorByType from '/imports/api/engine/computation/utility/findAncestorByType.js';
-import { traverse } from '/imports/parser/resolve.js';
-
-export default function linkCalculationDependencies(dependencyGraph, prop, { propsById }) {
-  prop._computationDetails.calculations.forEach(calcObj => {
-    // Store resolved ancestors
-    const memo = {
-      // ancestors: {} //this gets added if there are resolved ancestors
-    };
-    // Add this calculation to the dependency graph
-    const calcNodeId = `${prop._id}.${calcObj._key}`;
-    dependencyGraph.addNode(calcNodeId, calcObj);
-
-    // Traverse the parsed calculation looking for variable names
-    traverse(calcObj.parseNode, node => {
-      // Skip nodes that aren't symbols or accessors
-      if (node.parseType !== 'symbol' && node.parseType !== 'accessor') return;
-      // Link ancestor references as direct property dependencies
-      if (node.name[0] === '#') {
-        let ancestorProp = getAncestorProp(
-          node.name.slice(1), memo, prop, propsById
-        );
-        if (!ancestorProp) return;
-        // Link the ancestor prop as a direct dependency
-        // TODO: we might be referencing a calculation sub-field, depend on that instead
-        dependencyGraph.addLink(
-          calcNodeId, ancestorProp._id, 'ancestorReference'
-        );
-      } else {
-        // Link variable name references as variable dependencies
-        dependencyGraph.addLink(
-          calcNodeId, node.name, 'variableReference'
-        );
-      }
-    });
-    // Store the resolved ancestors in this calculation's local scope
-    if (memo.ancestors) {
-      calcObj._localScope = { ...calcObj._localScope, ...memo.ancestors };
-    }
-  });
-}
-
-function getAncestorProp(type, memo, prop, propsById) {
-  if (memo.ancestors && memo.ancestors['#' + type]) {
-    return memo.ancestors['#' + type];
-  } else {
-    var ancestorProp = findAncestorByType(prop, type, propsById);
-    if (!memo.ancestors) memo.ancestors = {};
-    memo.ancestors['#' + type] = ancestorProp;
-    return ancestorProp;
-  }
-}