@elyx-code/project-logic-tree 0.0.6850 → 0.0.6851

package/dist/index.d.ts

@@ -19631,6 +19631,9 @@ export declare enum BaseValueDescriptorIds {
    */
   export declare function getTouchedCanvasEntitiesFromChangeSet(changeSet: ChangeSet, options?: {
       shallowMissingActivesError?: boolean;
+      excludeAffected?: boolean;
+      excludeAdded?: boolean;
+      excludeUpdated?: boolean;
   }): CanvasEntityState[];
 
   export declare const getTzOffsetAtArg: IValueDescriptorTransfer;
@@ -31646,7 +31649,7 @@ export declare enum BaseValueDescriptorIds {
       SameBothGlobal = "same-both-global"
   }
 
-  export declare const SEARCH_STATEMENT_HYDRATION_EXPLANATION = "The 'query' field of 'search' entities gets stored naivly as pure text, but when we interact with it, it gets just-in-time hydration against the existing project state to become a fully typed SQL AST.\nThis means that you can write any raw SQL query in the 'query' field, and the project checks that any column and table references are actually found in the project.\nSpecifically the names of the 'properties' of any 'definition-entity' that implements the 'persisted built-in-base-entity' are matched against any columns and tables respectivly, found in the query.\nDefinition entity names are turned into table names by converting them to pascal case. For example \"My new Entity\" turns into \"MyNewEntity\".\nProperty names are turned into column names by converting them to camel case. For example \"My new property\" turns into \"myNewProperty\".\nIf any of the referenced tables or columns aren't found in the project, an error is shown and the referenced is SAFELY removed from the query.\nSame occurs with interpolated values.\nOnly 'input-map' values belonging to the same parent 'search' entity can be used inside the query. Like so: {{::inputMapId}}.\nIf any of the referenced input-maps aren't found in the parent 'search' entity, they will be ignored and SAFELY removed from the query, no errors are shown.\nA query (and therefore a 'search' entity) can only reference tables in a single database, if two 'definition-entities' that implement the persisted 'built-in-base-entity' belong to two different parent databases, the table selected first will determine what database is being queried, and the other table won't be available for this query.\nIf any of the referenced entities changes, the project will auto-update the query to reflect the changes.";
+  export declare const SEARCH_STATEMENT_HYDRATION_EXPLANATION = "The 'query' field of 'search' entities gets stored naivly as pure text, but when we interact with it, it gets just-in-time hydration against the existing project state to become a fully typed SQL AST.\nThis means that you can write any raw SQL query in the 'query' field, and the project checks that any column and table references are actually found in the project.\nSpecifically the names of the 'properties' of any 'definition-entity' that implements the \"persisted\" 'built-in-base-entity' are matched against any columns and tables, respectively, found in the query.\nDefinition entity names are turned into table names by converting them to pascal case. For example \"My new Entity\" turns into \"MyNewEntity\".\nProperty names are turned into column names by converting them to camel case. For example \"My new property\" turns into \"myNewProperty\".\nIf any of the referenced tables or columns aren't found in the project, an error is shown and the referenced is SAFELY removed from the query.\nSame occurs with interpolated values.\nOnly 'input-map' values belonging to the same parent 'search' entity can be used inside the query. Like so: {{::inputMapId}}.\nIf any of the referenced input-maps aren't found in the parent 'search' entity, they will be ignored and SAFELY removed from the query, no errors are shown.\nA query (and therefore a 'search' entity) can only reference tables in a single database, if two 'definition-entities' that implement the \"persisted\" 'built-in-base-entity' belong to two different parent databases, the table selected first will determine what database is being queried, and the other table won't be available for this query.\nIf any of the referenced entities changes, the project will auto-update the query to reflect the changes.";
 
   export declare enum SearchDependencyField {
       Parent = "search-parent-field",

package/dist/index.js

@@ -159547,7 +159547,13 @@ const Ci = class Ci extends Jr {
           message: `Entity of type "${a.type}" with id "${a.id}" has a 'query' field which could not be properly enriched due to an unknown error. This means, parts of the query were likely removed because they referenced missing entities in the project state.`
         })
       );
-    }), e.length && (c.push({
+    }), e.filter(
+      (E) => [
+        he.PropertyWithGivenNameNotFoundWhenEnrichingSQLQueryColumnAgainstProjectState,
+        he.PersistedEntityWithGivenNameNotFoundWhenEnrichingSQLQueryTableAgainstProjectState,
+        he.GenericSQLQueryEnrichmentError
+      ].includes(E.code)
+    ).length && (c.push({
       id: Ji.SearchStatementHydration,
       message: n4
     }), c.push(...a4(r).explanations)), {
@@ -159727,7 +159733,11 @@ You shouldn't have to manually update a 'parent' property. The equivalent result
       // includeComments: true, // Adds comments
       // includeRange: true, // Adds source code location data
     });
-    return Nc(e, this.project, null).errors.forEach((h) => {
+    return Nc(
+      e,
+      this.project,
+      null
+    ).errors.forEach((h) => {
       h.code === "not-found" ? h.entity === "column" ? r.push(
         new Re({
           id: `${c.id}--${he.PropertyWithGivenNameNotFoundWhenEnrichingSQLQueryColumnAgainstProjectState}--${h.name}`,
@@ -159753,7 +159763,9 @@ You shouldn't have to manually update a 'parent' property. The equivalent result
     }), r.length && (a.push({
       id: Ji.SearchStatementHydration,
       message: n4
-    }), a.push(...a4(this.project).explanations)), { errors: r, explanations: a, modifiedData: c };
+    }), a.push(
+      ...a4(this.project).explanations
+    )), { errors: r, explanations: a, modifiedData: c };
   }
   // Subscribe dependent entities to the current entity
   subscribeDependents(i) {
@@ -173199,18 +173211,23 @@ function mZi(l, p) {
         })
       ), a = !0);
     }), (c.DOWNSTREAM_PROPERTIES || []).forEach((G) => {
-      // @ts-ignore
-      l[G] && // @ts-ignore
-      !sT(l[G]) && (r.push(
-        new Re({
-          id: `${p.id}--${he.InvalidDownstreamPropertyOverride}`,
-          message: `Entity of type "${p.type}" with id "${p.id}" cannot have the property "${G}" set directly. It is a downstream property that points to a downstream nested entity.
+      if (
+        // @ts-ignore
+        l[G] && // @ts-ignore
+        !sT(l[G])
+      ) {
+        let W = `Entity of type "${p.type}" with id "${p.id}"`;
+        p.id || (W = `Entity of type "${p.type}" being updated`), r.push(
+          new Re({
+            id: `${p.id}--${he.InvalidDownstreamPropertyOverride}`,
+            message: `${W} cannot have the property "${G}" set directly. It is a downstream property that points to a downstream nested entity.
 All downstream references are managed by the downstream entity. Entities only manage their own upstream references.
 To modify '${G}', target the entity that it points to and its equivalent property.`,
-          severity: me.Error,
-          code: he.InvalidDownstreamPropertyOverride
-        })
-      ), a = !0);
+            severity: me.Error,
+            code: he.InvalidDownstreamPropertyOverride
+          })
+        ), a = !0;
+      }
     }), (c.INMUTABLE_UPSTREAM_PROPERTIES || []).forEach((G) => {
       // @ts-ignore
       l[G] && // @ts-ignore
@@ -173473,16 +173490,19 @@ function Yr(l, p) {
   );
   if (e) {
     (e.DOWNSTREAM_PROPERTIES || []).forEach((m) => {
-      l[m] && !sT(l[m]) && r.push(
-        new Re({
-          id: `${l.id}--${he.InvalidDownstreamPropertyOverride}`,
-          message: `Entity of type "${l.type}" with id "${l.id}" cannot have the property "${m}" set directly. It is a downstream property that points to a downstream nested entity.
+      if (l[m] && !sT(l[m])) {
+        let b = `Entity of type "${l.type}" with id "${l.id}"`;
+        l.id || (b = `Entity of type "${l.type}" being created`), r.push(
+          new Re({
+            id: `${l.id}--${he.InvalidDownstreamPropertyOverride}`,
+            message: `${b} cannot have the property "${m}" set directly. It is a downstream property that points to a downstream nested entity.
 All downstream references are managed by the downstream entity. Entities only manage their own upstream references.
 To modify '${m}', target the entity that it points to and its equivalent property.`,
-          severity: me.Error,
-          code: he.InvalidDownstreamPropertyOverride
-        })
-      );
+            severity: me.Error,
+            code: he.InvalidDownstreamPropertyOverride
+          })
+        );
+      }
     });
     const h = e.PROPERTIES || [];
     h.length > 0 && Object.keys(l).forEach((m) => {
@@ -173840,17 +173860,17 @@ In our case, first we need a 'variable-declaration' with a data-type that has it
 This variable-declaration acts as the initialization of the class. Only then we can use a SEPARATE variable-instance to call the internal-call on.
 This is equivalent to calling 'new' on a class to create an instance in Javascript, then calling a method on that instance in the next step. The internal call will have access to the state of the variable-declaration.`, cgi = "Not all methods of a definition-entity are available as internal calls. For a method to be available as an internal call its parent definition-entity needs to be the 'entity' of a data-type of a variable. It needs to belong to an 'interactive' definition-entity. It needs to not be part of an abstract definition-entity.", n4 = `The 'query' field of 'search' entities gets stored naivly as pure text, but when we interact with it, it gets just-in-time hydration against the existing project state to become a fully typed SQL AST.
 This means that you can write any raw SQL query in the 'query' field, and the project checks that any column and table references are actually found in the project.
-Specifically the names of the 'properties' of any 'definition-entity' that implements the 'persisted built-in-base-entity' are matched against any columns and tables respectivly, found in the query.
+Specifically the names of the 'properties' of any 'definition-entity' that implements the "persisted" 'built-in-base-entity' are matched against any columns and tables, respectively, found in the query.
 Definition entity names are turned into table names by converting them to pascal case. For example "My new Entity" turns into "MyNewEntity".
 Property names are turned into column names by converting them to camel case. For example "My new property" turns into "myNewProperty".
 If any of the referenced tables or columns aren't found in the project, an error is shown and the referenced is SAFELY removed from the query.
 Same occurs with interpolated values.
 Only 'input-map' values belonging to the same parent 'search' entity can be used inside the query. Like so: {{::inputMapId}}.
 If any of the referenced input-maps aren't found in the parent 'search' entity, they will be ignored and SAFELY removed from the query, no errors are shown.
-A query (and therefore a 'search' entity) can only reference tables in a single database, if two 'definition-entities' that implement the persisted 'built-in-base-entity' belong to two different parent databases, the table selected first will determine what database is being queried, and the other table won't be available for this query.
+A query (and therefore a 'search' entity) can only reference tables in a single database, if two 'definition-entities' that implement the "persisted" 'built-in-base-entity' belong to two different parent databases, the table selected first will determine what database is being queried, and the other table won't be available for this query.
 If any of the referenced entities changes, the project will auto-update the query to reflect the changes.`, E6 = `Persisted entities are an ORM-like system that allows the users to define SQL tables using 'definition-entities' that implement the "persisted" 'built-in-base-entity' (id: '${ae["built-in-base-entity"].BUILT_IN_PERSISTED_ENTITY_ENTITY.id}').
 If they are correctly linked to a database entity, these tables will then come with methods and built-in under the hood functionality to behave like SQL tables and when the project is published, they will generate in-code SQL migrations to generate or recover the corresponding tables in the given database.`, A6 = `To attach a persisted entity to a database, you need to set the 'valueAsTypeSingle' field of the 'defaultValue' of the static property that implements the built-in 'property' entity with the id '${ae["built-in-base-entity"].BUILT_IN_PERSISTED_ENTITY_ENTITY.properties.database.id}'.
-Definition entities have a 'properties' field, one of them should exist which implements said built-in 'property'.`;
+Definition entities have a list of child properties under the 'properties' field. If they implement said built-in 'property' it designates them as a column.`;
 var Ji = /* @__PURE__ */ ((l) => (l.PassThroughCallableEntities = "pass-through-callable-entities-explanation", l.EntryPointEntities = "entry-point-entities-explanation", l.CallerEntities = "caller-entities-explanation", l.CallableEntities = "callable-entities-explanation", l.CallsUpdate = "calls-update-explanation", l.BreakAndContinueStatements = "break-and-continue-statements-explanation", l.ReturnStatement = "return-statement-explanation", l.VariableDataTypeInferrance = "variable-data-type-inferrance-explanation", l.NonInteractiveBaseEntities = "non-interactive-base-entities-explanation", l.ValueReadingEntities = "value-reading-entities-explanation", l.ValueWritingEntities = "value-writing-entities-explanation", l.PropertyNotValueReaderWriter = "property-not-value-reader-writer-explanation", l.EntitiesWithValues = "entities-with-values-explanation", l.AIValueConnectionGenerationAction = "ai-value-connection-generation-action-explanation", l.ParentAutoCalculationFromCaller = "parent-auto-calculation-from-caller-explanation", l.DataTypeEntityField = "data-type-entity-field-explanation", l.DataTypeEntityFieldOptions = "data-type-entity-field-options-explanation", l.PropertyParentField = "property-parent-field-explanation", l.PropertyParentFieldOptions = "property-parent-field-options-explanation", l.MethodParentFieldOptions = "method-parent-field-options-explanation", l.AllAvailableValueReaderEntities = "all-available-value-reader-entities-explanation", l.AllAvailableValueWriterEntities = "all-available-value-writer-entities-explanation", l.AvailableValueReadersForGivenWriter = "available-value-readers-for-given-writer-explanation", l.AvailableValueWritersForGivenReader = "available-value-writers-for-given-reader-explanation", l.AllAvailableCallableEntities = "all-available-callable-entities-explanation", l.AllAvailableEntryPointEntities = "all-available-entry-point-entities-explanation", l.AllAvailablePassThroughCallableEntities = "all-available-pass-through-callable-entities-explanation", l.AllAvailableCallerEntities = "all-available-caller-entities-explanation", l.AllAvailableTerminationEntities = "all-available-termination-entities-explanation", l.AllAvailableCallerEntitiesForGivenCallee = "all-available-caller-entities-for-given-callee-explanation", l.AllAvailableCalleeEntitiesForGivenCaller = "all-available-callee-entities-for-given-caller-explanation", l.AllAvailableGlobalFunctionDeclarationsForFunctionCall = "all-available-global-function-declarations-for-function-call-explanation", l.AllNoneInteractiveBaseEntities = "all-non-interactive-base-entities-explanation", l.AllOperationActionDescriptors = "all-operation-action-descriptors-explanation", l.AllConditionActionDescriptors = "all-condition-action-descriptors-explanation", l.AllLoopActionDescriptors = "all-loop-action-descriptors-explanation", l.AllGlobalEventsActionDescriptors = "all-global-events-action-descriptors-explanation", l.DefinitionEntities = "definition-entities-explanation", l.PropertyImplementationAndExtensionAutoEnrichment = "property-implementation-and-extension-auto-enrichment-explanation", l.MethodImplementationAndExtensionAutoEnrichment = "method-implementation-and-extension-auto-enrichment-explanation", l.ActualOwnersOfMisplacedProperties = "actual-owners-of-misplaced-properties-explanation", l.EditingProperties = "editing-properties-explanation", l.MutableMetaProperties = "mutable-meta-properties-explanation", l.InmutableMetaProperties = "inmutable-meta-properties-explanation", l.InmutableUpstreamProperties = "inmutable-upstream-properties-explanation", l.DownstreamProperties = "downstream-properties-explanation", l.FullEditingProperties = "full-editing-properties-explanation", l.OutputMapsAutogeneration = "output-maps-autogeneration-explanation", l.AvailableOutputMapsForGivenParentCallableEntity = "available-output-maps-for-given-parent-callable-entity-explanation", l.InputMapsAutogeneration = "input-maps-autogeneration-explanation", l.InternalCallsAutogeneration = "internal-calls-autogeneration-explanation", l.AvailableInputMapsForGivenParentCallableEntity = "available-input-maps-for-given-parent-callable-entity-explanation", l.AvailableInternalCallsForGivenVariablesDataTypeEntity = "available-internal-calls-for-given-variables-data-type-entity-explanation", l.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables = "non-available-internal-calls-with-same-declaration-in-existing-instanciated-variables-explanation", l.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables = "available-internal-calls-with-same-declaration-in-existing-instanciated-variables-explanation", l.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities = "available-internal-calls-of-any-declaration-in-all-instanciated-variables-data-type-entities-explanation", l.AllAvailableMethodsThatCanBeCalledAsInternalCalls = "all-available-methods-that-can-be-called-as-internal-calls", l.InternalCalls = "internal-calls-explanation", l.ReasonsForMethodsNotAvailableAsInternalCalls = "reasons-for-methods-not-available-as-internal-calls-explanation", l.AllNonInteractiveDefinitionEntities = "all-non-interactive-definition-entities-explanation", l.AllStaticAndAbstractDefinitionEntities = "all-static-and-abstract-definition-entities-explanation", l.AllStaticNonAbstractDefinitionEntities = "all-static-non-abstract-definition-entities-explanation", l.AllAbstractNonStaticDefinitionEntities = "all-abstract-non-static-definition-entities-explanation", l.AllInstanciatableDefinitionEntities = "all-instantiatable-definition-entities-explanation", l.AutoReplacedExistingValueWriterForNewGiven = "auto-replaced-existing-value-writer-for-new-given-explanation", l.AutoResolvedCalledByBasedOnValueWriter = "auto-resolved-calledBy-based-on-value-writer-explanation", l.AllAvailableColumnNamesForSQLEnrichmentInCurrentQuery = "all-available-column-names-for-sql-enrichment-in-current-query-explanation", l.AllPropertiesThatCouldBeSelectedAsColumnsInSQLQuery = "all-properties-that-could-be-selected-as-columns-in-sql-query-explanation", l.AllTableNamesForSQLEnrichmentForGivenDatabase = "all-table-names-for-sql-enrichment-for-given-database-explanation", l.AllTableNamesForSQLEnrichment = "all-table-names-for-sql-enrichment-explanation", l.SearchStatementHydration = "search-statement-hydration-explanation", l.PersistedEntities = "persisted-entities-explanation", l.AttachingPersistedEntitiesToDatabases = "attaching-persisted-entities-to-databases-explanation", l.FullSQLSelectableBreakdown = "full-sql-selectable-breakdown-explanation", l.CurrentlyUnattachedPersistedEntities = "currently-unattached-persisted-entities-explanation", l))(Ji || {});
 function Oc(l) {
   return `\`\`\`json
@@ -175462,72 +175482,72 @@ function HE(l) {
 }
 function a4(l) {
   const p = [], i = l.entities.filter(
-    (c) => di(c, ge.RELATIONAL_DATABASE)
+    (e) => di(e, ge.RELATIONAL_DATABASE)
+  ), r = l.entities.filter(
+    (e) => di(e, ge.PERSISTED_ENTITY) && !eT(e)
   );
-  if (l.entities.filter(
-    (c) => di(c, ge.PERSISTED_ENTITY) && !eT(c)
-  ).some(
-    (c) => l.entities.some(
-      (e) => {
-        var f;
-        return di(
-          e,
-          ge.RELATIONAL_DATABASE
-        ) && ((f = eT(c)) == null ? void 0 : f.id) === e.id && dn(c).length > 0;
+  let a = i.some(
+    (e) => l.entities.some(
+      (f) => {
+        var h;
+        return di(f, ge.PERSISTED_ENTITY) && ((h = eT(f)) == null ? void 0 : h.id) === e.id && dn(f).length > 0;
       }
     )
-  )) {
-    let c = "All available entities with their SQL names that can be used in the SQL 'query' field in a 'search' entity are:";
-    i.forEach((e) => {
-      const f = de(e, l), h = e.id, m = l.entities.filter(
-        (b) => {
-          var E;
-          return di(b, ge.PERSISTED_ENTITY) && ((E = eT(b)) == null ? void 0 : E.id) === e.id;
+  ), c = r.length || i.length;
+  if (a) {
+    let e = "All available entities with their SQL names that can be used in the SQL 'query' field in a 'search' entity are:";
+    i.forEach((f) => {
+      const h = de(f, l), m = f.id, b = l.entities.filter(
+        (E) => {
+          var I;
+          return di(E, ge.PERSISTED_ENTITY) && ((I = eT(E)) == null ? void 0 : I.id) === f.id;
         }
       );
-      m.length ? (c += `
-- Database "${f}" with id ${h} has the following tables (persisted definition-entities):`, m.forEach((b) => {
-        const E = de(b, l), I = Ld(E), _ = b.id, P = dn(b);
-        P.length ? c += `
-  - "${E}" with id ${_} => Table name: "${I}" | Has the following columns (applicable 'properties'):
-		- ${P.map((N) => {
-          const B = de(N, l), U = N.codeName || Qs(Qi(B));
-          return `${B} (${N.id}) => Column name: "${U}"`;
+      b.length ? (e += `
+- Database "${h}" with id ${m} has the following tables (persisted definition-entities):`, b.forEach((E) => {
+        const I = de(E, l), _ = Ld(I), P = E.id, N = dn(E);
+        N.length ? e += `
+  - "${I}" with id ${P} => Table name: "${_}" | Has the following columns (applicable 'properties'):
+		- ${N.map((B) => {
+          const U = de(B, l), G = B.codeName || Qs(Qi(U));
+          return `${U} (${B.id}) => Column name: "${G}"`;
         }).join(`
-		- `)}.` : c += `
-  - "${E}" with id ${_} => Table name: "${I}" | Has no columns (applicable 'properties').`;
-      })) : c += `
-- Database "${f}" with id ${h} does not have any tables (persisted definition-entities) and thus cannot be yet be interacted with in a query.`;
+   - `)}.` : e += `
+  - "${I}" with id ${P} => Table name: "${_}" | Has no columns (applicable 'properties').`;
+      })) : e += `
+- Database "${h}" with id ${m} does not have any tables (persisted definition-entities) and thus cannot be yet be interacted with in a query.`;
     }), p.push({
       id: "full-sql-selectable-breakdown-explanation",
-      message: c
+      message: e
     });
   } else {
-    let c = `There are currently no entities that can be used in an SQL 'query' field in a 'search' entity.
+    let e = `There are currently no entities that can be used in an SQL 'query' field in a 'search' entity.
 For an entity to be available for selection it needs to be a well formed "persisted" 'definition-entity' with at least one column property.`;
-    i.forEach((e) => {
-      const f = de(e, l), h = e.id, m = l.entities.filter(
-        (b) => {
-          var E;
-          return di(b, ge.PERSISTED_ENTITY) && ((E = eT(b)) == null ? void 0 : E.id) === e.id;
+    c && (e += `
+
+However, here is a breakdown of all persisted entities and their SQL names, even if they aren't selectable yet:`, i.forEach((f) => {
+      const h = de(f, l), m = f.id, b = l.entities.filter(
+        (E) => {
+          var I;
+          return di(E, ge.PERSISTED_ENTITY) && ((I = eT(E)) == null ? void 0 : I.id) === f.id;
         }
       );
-      m.length ? (c += `
-- Database "${f}" with id ${h} has the following tables (persisted definition-entities):`, m.forEach((b) => {
-        const E = de(b, l), I = Ld(E), _ = b.id, P = dn(b);
-        P.length ? c += `
-  - "${E}" with id ${_} => Table name: "${I}" | Has the following columns (applicable 'properties'):
-		- ${P.map((N) => {
-          const B = de(N, l), U = N.codeName || Qs(Qi(B));
-          return `${B} (${N.id}) => Column name: "${U}"`;
+      b.length ? (e += `
+- Database "${h}" with id ${m} has the following tables (persisted definition-entities):`, b.forEach((E) => {
+        const I = de(E, l), _ = Ld(I), P = E.id, N = dn(E);
+        N.length ? e += `
+  - "${I}" with id ${P} => Table name: "${_}" | Has the following columns (applicable 'properties'):
+		- ${N.map((B) => {
+          const U = de(B, l), G = B.codeName || Qs(Qi(U));
+          return `${U} (${B.id}) => Column name: "${G}"`;
         }).join(`
-		- `)}.` : c += `
-  - "${E}" with id ${_} => Table name: "${I}" | Has no columns (applicable 'properties').`;
-      })) : c += `
-- Database "${f}" with id ${h} does not have any tables (persisted definition-entities) and thus cannot be yet be interacted with in a query.`;
-    }), p.push({
+   - `)}.` : e += `
+  - "${I}" with id ${P} => Table name: "${_}" | Has no columns (applicable 'properties').`;
+      })) : e += `
+- Database "${h}" with id ${m} does not have any tables (persisted definition-entities) and thus cannot be yet be interacted with in a query.`;
+    })), p.push({
       id: "full-sql-selectable-breakdown-explanation",
-      message: c
+      message: e
     }), p.push({
       id: "persisted-entities-explanation",
       message: E6
@@ -196920,12 +196940,15 @@ function rP(l, p = {}) {
 function k6i(l, p = {}) {
   const i = {
     shallowMissingActivesError: !1,
+    excludeAffected: !1,
+    excludeAdded: !1,
+    excludeUpdated: !1,
     ...p
   }, r = [], a = /* @__PURE__ */ new Set();
   return [
-    ...l.listAdded,
-    ...l.listUpdated,
-    ...l.listAffected
+    ...i.excludeAdded ? [] : l.listAdded,
+    ...i.excludeUpdated ? [] : l.listUpdated,
+    ...i.excludeAffected ? [] : l.listAffected
   ].forEach((e) => {
     var m;
     const f = Tt(e);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elyx-code/project-logic-tree",
-	"version": "0.0.6850",
+	"version": "0.0.6851",
 	"author": "Sergio Herrero",
 	"license": "UNLICENSED",
 	"description": "An installable module which contains the type definitions and ephemeral state management for a projects' logic tree data structure",