joist-core 2.3.0-next.51 → 2.3.0-next.53
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/build/withLoaded.cjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"withLoaded.cjs","names":["maybePromiseThen","isRelation","isProperty","isReactiveField","isReactiveGetter","isAsyncReactiveField","isLoadedReference","isLoadedCollection","isLoadedProperty","isLoadedAsyncReactiveField","fail"],"sources":["../src/withLoaded.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"./loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"./relations/AsyncReactiveField.ts\";\nimport {\n type LoadedCollection,\n type LoadedProperty,\n type LoadedReadOnlyCollection,\n type LoadedReference,\n type PolymorphicReference,\n isAsyncReactiveField,\n isLoadedCollection,\n isLoadedProperty,\n isLoadedReference,\n isProperty,\n isReactiveField,\n isReactiveGetter,\n isRelation,\n} from \"./relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"./utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> =
|
|
1
|
+
{"version":3,"file":"withLoaded.cjs","names":["maybePromiseThen","isRelation","isProperty","isReactiveField","isReactiveGetter","isAsyncReactiveField","isLoadedReference","isLoadedCollection","isLoadedProperty","isLoadedAsyncReactiveField","fail"],"sources":["../src/withLoaded.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"./loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"./relations/AsyncReactiveField.ts\";\nimport {\n type LoadedCollection,\n type LoadedProperty,\n type LoadedReadOnlyCollection,\n type LoadedReference,\n type PolymorphicReference,\n type Property,\n type Relation,\n isAsyncReactiveField,\n isLoadedCollection,\n isLoadedProperty,\n isLoadedReference,\n isProperty,\n isReactiveField,\n isReactiveGetter,\n isRelation,\n} from \"./relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"./utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n [\n K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n ? L[K] extends LoadedReference<T, U, N>\n ? U | N\n : L[K]\n : L[K] extends LoadedReference<T, infer U, never>\n ? U\n : L[K] extends LoadedReference<T, infer U, undefined>\n ? U | undefined\n : L[K] extends LoadedCollection<T, infer U>\n ? U[]\n : L[K] extends LoadedReadOnlyCollection<T, infer U>\n ? // leaving out `readonly U[]` until we're ready to switch\n U[]\n : L[K] extends LoadedProperty<T, infer V>\n ? V\n : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n return maybePromiseThen(\n loadedOrPromise,\n (loaded) =>\n new Proxy(loaded, {\n get: (target, prop) => {\n const value: any = (target as any)[prop];\n if (\n isRelation(value) ||\n isProperty(value) ||\n isReactiveField(value) ||\n isReactiveGetter(value) ||\n isAsyncReactiveField(value)\n ) {\n return isLoadedReference(value) ||\n isLoadedCollection(value) ||\n isLoadedProperty(value) ||\n isReactiveField(value) ||\n isLoadedAsyncReactiveField(value) ||\n isReactiveGetter(value)\n ? value.get\n : fail(`${target}.${String(prop)} is not loaded`);\n } else if (value instanceof StubbedRelation) {\n return value.get;\n } else {\n return value;\n }\n },\n }) as WithLoaded<T, H, L>,\n );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n entity: T,\n hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n assertLoaded<T, H>(entity, hint);\n return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n * get: () => new StubbedRelation([]),\n * });\n * ```\n */\nexport class StubbedRelation {\n constructor(private value: any) {}\n\n get get() {\n return this.value;\n }\n\n get isLoaded() {\n return true;\n }\n\n load() {\n return this.get;\n }\n}\n"],"mappings":";;;;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAOA,cAAAA,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACEC,2BAAAA,WAAW,KAAK,KAChBC,8BAAAA,WAAW,KAAK,KAChBC,gCAAAA,gBAAgB,KAAK,KACrBC,iCAAAA,iBAAiB,KAAK,KACtBC,qCAAAA,qBAAqB,KAAK,GAE1B,OAAOC,4BAAAA,kBAAkB,KAAK,KAC5BC,6BAAAA,mBAAmB,KAAK,KACxBC,8BAAAA,iBAAiB,KAAK,KACtBL,gCAAAA,gBAAgB,KAAK,KACrBM,qCAAAA,2BAA2B,KAAK,KAChCL,iCAAAA,iBAAiB,KAAK,IACpB,MAAM,MACNM,cAAAA,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,kBAAA,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}
|
package/build/withLoaded.d.cts
CHANGED
|
@@ -1,13 +1,16 @@
|
|
|
1
1
|
import { LoadedCollection } from "./relations/Collection.cjs";
|
|
2
|
-
import { LoadedProperty } from "./relations/hasProperty.cjs";
|
|
2
|
+
import { LoadedProperty, Property } from "./relations/hasProperty.cjs";
|
|
3
3
|
import { LoadedReference } from "./relations/Reference.cjs";
|
|
4
|
+
import { Relation } from "./relations/Relation.cjs";
|
|
4
5
|
import { PolymorphicReference } from "./relations/PolymorphicReference.cjs";
|
|
5
6
|
import { LoadedReadOnlyCollection } from "./relations/ReadOnlyCollection.cjs";
|
|
6
7
|
import "./relations/index.cjs";
|
|
7
8
|
import { LoadHint, Loaded } from "./loadHints.cjs";
|
|
8
9
|
import { Entity } from "./Entity.cjs";
|
|
9
10
|
//#region src/withLoaded.d.ts
|
|
10
|
-
type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> =
|
|
11
|
+
type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
|
|
12
|
+
get: unknown;
|
|
13
|
+
} ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };
|
|
11
14
|
/**
|
|
12
15
|
* Allows destructuring against entities to more succinctly access loaded relations.
|
|
13
16
|
*
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../src/withLoaded.ts"],"mappings":"
|
|
1
|
+
{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../src/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}
|
package/build/withLoaded.d.mts
CHANGED
|
@@ -1,13 +1,16 @@
|
|
|
1
1
|
import { LoadedCollection } from "./relations/Collection.mjs";
|
|
2
|
-
import { LoadedProperty } from "./relations/hasProperty.mjs";
|
|
2
|
+
import { LoadedProperty, Property } from "./relations/hasProperty.mjs";
|
|
3
3
|
import { LoadedReference } from "./relations/Reference.mjs";
|
|
4
|
+
import { Relation } from "./relations/Relation.mjs";
|
|
4
5
|
import { PolymorphicReference } from "./relations/PolymorphicReference.mjs";
|
|
5
6
|
import { LoadedReadOnlyCollection } from "./relations/ReadOnlyCollection.mjs";
|
|
6
7
|
import "./relations/index.mjs";
|
|
7
8
|
import { LoadHint, Loaded } from "./loadHints.mjs";
|
|
8
9
|
import { Entity } from "./Entity.mjs";
|
|
9
10
|
//#region src/withLoaded.d.ts
|
|
10
|
-
type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> =
|
|
11
|
+
type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
|
|
12
|
+
get: unknown;
|
|
13
|
+
} ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };
|
|
11
14
|
/**
|
|
12
15
|
* Allows destructuring against entities to more succinctly access loaded relations.
|
|
13
16
|
*
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../src/withLoaded.ts"],"mappings":"
|
|
1
|
+
{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../src/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}
|
package/build/withLoaded.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"withLoaded.js","names":[],"sources":["../src/withLoaded.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"./loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"./relations/AsyncReactiveField.ts\";\nimport {\n type LoadedCollection,\n type LoadedProperty,\n type LoadedReadOnlyCollection,\n type LoadedReference,\n type PolymorphicReference,\n isAsyncReactiveField,\n isLoadedCollection,\n isLoadedProperty,\n isLoadedReference,\n isProperty,\n isReactiveField,\n isReactiveGetter,\n isRelation,\n} from \"./relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"./utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> =
|
|
1
|
+
{"version":3,"file":"withLoaded.js","names":[],"sources":["../src/withLoaded.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"./loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"./relations/AsyncReactiveField.ts\";\nimport {\n type LoadedCollection,\n type LoadedProperty,\n type LoadedReadOnlyCollection,\n type LoadedReference,\n type PolymorphicReference,\n type Property,\n type Relation,\n isAsyncReactiveField,\n isLoadedCollection,\n isLoadedProperty,\n isLoadedReference,\n isProperty,\n isReactiveField,\n isReactiveGetter,\n isRelation,\n} from \"./relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"./utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n [\n K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n ? L[K] extends LoadedReference<T, U, N>\n ? U | N\n : L[K]\n : L[K] extends LoadedReference<T, infer U, never>\n ? U\n : L[K] extends LoadedReference<T, infer U, undefined>\n ? U | undefined\n : L[K] extends LoadedCollection<T, infer U>\n ? U[]\n : L[K] extends LoadedReadOnlyCollection<T, infer U>\n ? // leaving out `readonly U[]` until we're ready to switch\n U[]\n : L[K] extends LoadedProperty<T, infer V>\n ? V\n : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n return maybePromiseThen(\n loadedOrPromise,\n (loaded) =>\n new Proxy(loaded, {\n get: (target, prop) => {\n const value: any = (target as any)[prop];\n if (\n isRelation(value) ||\n isProperty(value) ||\n isReactiveField(value) ||\n isReactiveGetter(value) ||\n isAsyncReactiveField(value)\n ) {\n return isLoadedReference(value) ||\n isLoadedCollection(value) ||\n isLoadedProperty(value) ||\n isReactiveField(value) ||\n isLoadedAsyncReactiveField(value) ||\n isReactiveGetter(value)\n ? value.get\n : fail(`${target}.${String(prop)} is not loaded`);\n } else if (value instanceof StubbedRelation) {\n return value.get;\n } else {\n return value;\n }\n },\n }) as WithLoaded<T, H, L>,\n );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n entity: T,\n hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n assertLoaded<T, H>(entity, hint);\n return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n * get: () => new StubbedRelation([]),\n * });\n * ```\n */\nexport class StubbedRelation {\n constructor(private value: any) {}\n\n get get() {\n return this.value;\n }\n\n get isLoaded() {\n return true;\n }\n\n load() {\n return this.get;\n }\n}\n"],"mappings":";;;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAO,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACE,WAAW,KAAK,KAChB,WAAW,KAAK,KAChB,gBAAgB,KAAK,KACrB,iBAAiB,KAAK,KACtB,qBAAqB,KAAK,GAE1B,OAAO,kBAAkB,KAAK,KAC5B,mBAAmB,KAAK,KACxB,iBAAiB,KAAK,KACtB,gBAAgB,KAAK,KACrB,2BAA2B,KAAK,KAChC,iBAAiB,KAAK,IACpB,MAAM,MACN,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "joist-core",
|
|
3
|
-
"version": "2.3.0-next.
|
|
3
|
+
"version": "2.3.0-next.53",
|
|
4
4
|
"license": "MIT",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"repository": {
|
|
@@ -42,7 +42,7 @@
|
|
|
42
42
|
"build"
|
|
43
43
|
],
|
|
44
44
|
"peerDependencies": {
|
|
45
|
-
"joist-utils": "2.3.0-next.
|
|
45
|
+
"joist-utils": "2.3.0-next.53"
|
|
46
46
|
},
|
|
47
47
|
"dependencies": {
|
|
48
48
|
"ansis": "^4.3.1",
|