@afora/core 0.0.7 → 0.0.9

package/dist/experimental.js

@@ -1,47 +1,63 @@
 import {
-  isBlueprint2,
-  isRecordClass2,
-  recordFieldOf2,
+  propertyLineageOf2,
+  isBlueprint,
+  isRecordClass,
+  recordFieldOf,
+  InvalidBlueprintVariant2,
+  UndeclaredBlueprintProperty2,
+  isBlueprintVariant,
   recordNameOf2,
   listOf2,
-  isBlueprintList2,
-  AbstractRecord2,
-  declareRecord,
+  isBlueprintList,
+  AbstractRecord,
   optionalOf2,
-  UndeclaredBlueprintProperty2,
-  blueprintFromProperties
-} from "./index-r78dsvtc.js";
-
+  blueprintFromProperties,
+  declareRecord,
+  stageDescriptionOf2,
+  InvalidJwtOptions2,
+  jwtOf2
+} from "./index-xegv6a1p.js";
+import {
+  providerDescriptionOf2,
+  prepareQuery2,
+  sameValue2,
+  matchesQuery2,
+  selectRows2,
+  useCaseTargetOf2,
+  useCaseOriginOf2,
+  eventPolicyDescriptionOf2,
+  eventPolicyCatalogOf2
+} from "./index-3aae5jfq.js";
 // src/core/blueprint/slice.ts
 function propertiesOfField(field) {
   if (field === undefined)
     return;
-  if (isBlueprintList2(field))
+  if (isBlueprintList(field))
     return propertiesOfField(field.item);
-  const record = recordFieldOf2(field);
+  const record = recordFieldOf(field);
   if (record)
     return record.record.blueprint.properties;
-  return isBlueprint2(field) ? field.properties : undefined;
+  return isBlueprint(field) ? field.properties : undefined;
 }
 function maskOf(selector, against) {
-  if (isRecordClass2(selector))
+  if (isRecordClass(selector))
     return maskOf(selector.blueprint, against);
-  if (isBlueprint2(selector)) {
+  if (isBlueprint(selector)) {
     return Object.fromEntries(Object.entries(selector.properties).map(([key, field]) => [key, fieldMaskOf(field, against?.[key])]));
   }
   return selector;
 }
 function fieldMaskOf(field, other) {
-  if (isBlueprintList2(field)) {
-    return fieldMaskOf(field.item, isBlueprintList2(other) ? other.item : other);
+  if (isBlueprintList(field)) {
+    return fieldMaskOf(field.item, isBlueprintList(other) ? other.item : other);
   }
-  const record = recordFieldOf2(field);
+  const record = recordFieldOf(field);
   if (record) {
-    if (record.record === recordFieldOf2(other)?.record)
+    if (record.record === recordFieldOf(other)?.record)
       return true;
     return maskOf(record.record, propertiesOfField(other));
   }
-  if (isBlueprint2(field)) {
+  if (isBlueprint(field)) {
     return field === other ? true : maskOf(field, propertiesOfField(other));
   }
   return true;
@@ -66,7 +82,7 @@ function slicedRecordOf(Original, mask, path) {
   const blueprint = blueprintFromProperties(source.plugins, sliceCollection(source.properties, mask, `${path}.`));
   const kept = (keys) => keys.filter((key) => Object.hasOwn(blueprint.properties, key));
   const { sensitive, unique, change } = Original.options;
-  const Sliced = declareRecord(AbstractRecord2, blueprint, {
+  const Sliced = declareRecord(AbstractRecord, blueprint, {
     sensitive: kept(sensitive),
     unique: kept(unique),
     change: kept(change)
@@ -81,22 +97,31 @@ function slicedRecordOf(Original, mask, path) {
 function sliceField(field, selected, path) {
   if (selected === true)
     return field;
-  if (isBlueprintList2(field)) {
+  if (isBlueprintList(field)) {
     const list = listOf2(sliceField(field.item, selected, path), {
       minItems: field.minItems,
       maxItems: field.maxItems
     });
     return field.optional ? optionalOf2(list) : list;
   }
-  const record = recordFieldOf2(field);
+  const record = recordFieldOf(field);
   if (record) {
     const sliced = slicedRecordOf(record.record, selected, path);
     return record.optional ? optionalOf2(sliced) : sliced;
   }
-  if (isBlueprint2(field)) {
+  if (isBlueprint(field)) {
     const sliced = blueprintFromProperties(field.plugins, sliceCollection(field.properties, selected, `${path}.`));
     return field.optional ? optionalOf2(sliced) : sliced;
   }
+  if (isBlueprintVariant(field)) {
+    throw new InvalidBlueprintVariant2({
+      source: "blueprint",
+      details: {
+        key: field.key,
+        reason: `"${path}" cannot be sliced by its keys yet, only picked whole`
+      }
+    });
+  }
   throw new UndeclaredBlueprintProperty2({
     source: "blueprint",
     details: { key: `${path}.${Object.keys(selected)[0] ?? ""}` }
@@ -109,7 +134,7 @@ function pick(value, mask) {
     return value.map((item) => pick(item, mask));
   if (typeof value !== "object" || value === null)
     return value;
-  const source = isRecordClass2(value.constructor) ? value.toJSON() : value;
+  const source = isRecordClass(value.constructor) ? value.toJSON() : value;
   const picked = {};
   for (const [key, selected] of Object.entries(mask)) {
     if (!selected || !Object.hasOwn(source, key))
@@ -119,6 +144,19 @@ function pick(value, mask) {
   return picked;
 }
 export {
+  InvalidJwtOptions2 as InvalidJwtOptions,
+  eventPolicyCatalogOf2 as eventPolicyCatalogOf,
+  eventPolicyDescriptionOf2 as eventPolicyDescriptionOf,
+  jwtOf2 as jwtOf,
+  matchesQuery2 as matchesQuery,
+  prepareQuery2 as prepareQuery,
+  propertyLineageOf2 as propertyLineageOf,
+  providerDescriptionOf2 as providerDescriptionOf,
+  sameValue2 as sameValue,
+  selectRows2 as selectRows,
   sliceOf,
-  sliceValue
+  sliceValue,
+  stageDescriptionOf2 as stageDescriptionOf,
+  useCaseOriginOf2 as useCaseOriginOf,
+  useCaseTargetOf2 as useCaseTargetOf
 };