joist-core 2.3.0-next.43 → 2.3.0-next.45
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/newTestInstance.d.cts +3 -3
- package/build/newTestInstance.d.cts.map +1 -1
- package/build/newTestInstance.d.mts +3 -3
- package/build/newTestInstance.d.mts.map +1 -1
- package/build/temporal.cjs.map +1 -1
- package/build/temporal.d.cts +4 -21
- package/build/temporal.d.cts.map +1 -1
- package/build/temporal.d.mts +4 -21
- package/build/temporal.d.mts.map +1 -1
- package/build/temporal.js.map +1 -1
- package/build/temporalMappers.cjs +1 -1
- package/build/temporalMappers.cjs.map +1 -1
- package/build/temporalMappers.js +1 -1
- package/build/temporalMappers.js.map +1 -1
- package/package.json +2 -2
|
@@ -37,9 +37,9 @@ type FactoryOpts<T extends Entity> = DeepPartialOpts<T> & {
|
|
|
37
37
|
useLogging?: boolean;
|
|
38
38
|
} & { [K in keyof FactoryExtrasOf<T>]?: FactoryExtrasOf<T>[K]; };
|
|
39
39
|
declare const testDate: Date;
|
|
40
|
-
declare const testPlainDate: Temporal.PlainDate | undefined;
|
|
41
|
-
declare const testPlainDateTime: Temporal.PlainDateTime | undefined;
|
|
42
|
-
declare const testZonedDateTime: Temporal.ZonedDateTime | undefined;
|
|
40
|
+
declare const testPlainDate: import("temporal-spec").Temporal.PlainDate | undefined;
|
|
41
|
+
declare const testPlainDateTime: import("temporal-spec").Temporal.PlainDateTime | undefined;
|
|
42
|
+
declare const testZonedDateTime: import("temporal-spec").Temporal.ZonedDateTime | undefined;
|
|
43
43
|
/**
|
|
44
44
|
* Creates a test instance of `T`.
|
|
45
45
|
*
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"newTestInstance.d.cts","names":[],"sources":["../src/newTestInstance.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuDa,WAAW;;;;;;;;;;;;KAyBZ,YAAY,UAAU,UAAU,gBAAgB;EAC1D;EACA,MAAM,SAAS;EACf;EACA;EACA;OAIC,WAAW,gBAAgB,MAAM,gBAAgB,GAAG;cAK1C,UAAQ;cAER,
|
|
1
|
+
{"version":3,"file":"newTestInstance.d.cts","names":[],"sources":["../src/newTestInstance.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuDa,WAAW;;;;;;;;;;;;KAyBZ,YAAY,UAAU,UAAU,gBAAgB;EAC1D;EACA,MAAM,SAAS;EACf;EACA;EACA;OAIC,WAAW,gBAAgB,MAAM,gBAAgB,GAAG;cAK1C,UAAQ;cAER,uCAAa,SAAA;cACb,2CAAiB,SAAA;cACjB,2CAAiB,SAAA;;;;;;;;;iBAYd,gBAAgB,UAAU,QACxC,IAAI,eACJ,MAAM,kBAAkB,IAExB;;AAAA,WAAU,YAAY,IAEtB;;AAAA,cAAa,YAAY;EACvB,eAAe,MAAM,OAAO,IAAI,UAAU,QAAQ;IAEnD,QAAQ;;;;;;;cAqYE;;;;;;;;;;;;;iBAmBG,aAAa,MAAM;;;;;;;;;iBAYnB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCd,iBAAiB,GAAG,OAAO,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BlD,SAAS,UAAU,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBA2B1E,aAAa,UAAU,QAAQ,aAAa,IAAI,GAC9D,WAAW,kBAAkB,OAC7B;EACE,YAAY,kBAAkB;EAC9B,sBAAsB,+BAA+B;IAEtD,iBAAiB;;;;;;;;;;iBAqBJ,aAAa,UAAU,QAAQ,IAAI,eAAe,MAAM,+BAA+B;KAiDlG,UAAU,KAAK;KAEf,gBAAgB,UAAU,UAAU,yBAAyB,OAAO;;KAG7D,iBAAiB,UAAU,UACnC,IAKA,KAAK,MACJ,kBAAkB;EAAO;;KAEzB,yBAAyB,QAC3B,WAAW,KAAK,EAAE,WAAW,gBAAgB,KAC1C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,iBAAiB,MACvB,EAAE,KACJ,UAAU,SACR,iBAAiB,KACjB,EAAE,KACN,EAAE;KAUI;;iBA8II,kBAAkB;;cAKrB;WACiB;EAA5B,YAA4B;;iBAGd,kBAAkB,QAAQ;iBAI1B"}
|
|
@@ -37,9 +37,9 @@ type FactoryOpts<T extends Entity> = DeepPartialOpts<T> & {
|
|
|
37
37
|
useLogging?: boolean;
|
|
38
38
|
} & { [K in keyof FactoryExtrasOf<T>]?: FactoryExtrasOf<T>[K]; };
|
|
39
39
|
declare const testDate: Date;
|
|
40
|
-
declare const testPlainDate: Temporal.PlainDate | undefined;
|
|
41
|
-
declare const testPlainDateTime: Temporal.PlainDateTime | undefined;
|
|
42
|
-
declare const testZonedDateTime: Temporal.ZonedDateTime | undefined;
|
|
40
|
+
declare const testPlainDate: import("temporal-spec").Temporal.PlainDate | undefined;
|
|
41
|
+
declare const testPlainDateTime: import("temporal-spec").Temporal.PlainDateTime | undefined;
|
|
42
|
+
declare const testZonedDateTime: import("temporal-spec").Temporal.ZonedDateTime | undefined;
|
|
43
43
|
/**
|
|
44
44
|
* Creates a test instance of `T`.
|
|
45
45
|
*
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"newTestInstance.d.mts","names":[],"sources":["../src/newTestInstance.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuDa,WAAW;;;;;;;;;;;;KAyBZ,YAAY,UAAU,UAAU,gBAAgB;EAC1D;EACA,MAAM,SAAS;EACf;EACA;EACA;OAIC,WAAW,gBAAgB,MAAM,gBAAgB,GAAG;cAK1C,UAAQ;cAER,
|
|
1
|
+
{"version":3,"file":"newTestInstance.d.mts","names":[],"sources":["../src/newTestInstance.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuDa,WAAW;;;;;;;;;;;;KAyBZ,YAAY,UAAU,UAAU,gBAAgB;EAC1D;EACA,MAAM,SAAS;EACf;EACA;EACA;OAIC,WAAW,gBAAgB,MAAM,gBAAgB,GAAG;cAK1C,UAAQ;cAER,uCAAa,SAAA;cACb,2CAAiB,SAAA;cACjB,2CAAiB,SAAA;;;;;;;;;iBAYd,gBAAgB,UAAU,QACxC,IAAI,eACJ,MAAM,kBAAkB,IAExB;;AAAA,WAAU,YAAY,IAEtB;;AAAA,cAAa,YAAY;EACvB,eAAe,MAAM,OAAO,IAAI,UAAU,QAAQ;IAEnD,QAAQ;;;;;;;cAqYE;;;;;;;;;;;;;iBAmBG,aAAa,MAAM;;;;;;;;;iBAYnB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCd,iBAAiB,GAAG,OAAO,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BlD,SAAS,UAAU,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBA2B1E,aAAa,UAAU,QAAQ,aAAa,IAAI,GAC9D,WAAW,kBAAkB,OAC7B;EACE,YAAY,kBAAkB;EAC9B,sBAAsB,+BAA+B;IAEtD,iBAAiB;;;;;;;;;;iBAqBJ,aAAa,UAAU,QAAQ,IAAI,eAAe,MAAM,+BAA+B;KAiDlG,UAAU,KAAK;KAEf,gBAAgB,UAAU,UAAU,yBAAyB,OAAO;;KAG7D,iBAAiB,UAAU,UACnC,IAKA,KAAK,MACJ,kBAAkB;EAAO;;KAEzB,yBAAyB,QAC3B,WAAW,KAAK,EAAE,WAAW,gBAAgB,KAC1C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,iBAAiB,MACvB,EAAE,KACJ,UAAU,SACR,iBAAiB,KACjB,EAAE,KACN,EAAE;KAUI;;iBA8II,kBAAkB;;cAKrB;WACiB;EAA5B,YAA4B;;iBAGd,kBAAkB,QAAQ;iBAI1B"}
|
package/build/temporal.cjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"temporal.cjs","names":["createRequire"],"sources":["../src/temporal.ts"],"sourcesContent":["/// <reference types=\"temporal-spec/global\" preserve=\"true\" />\n\nimport { createRequire } from \"node:module\";\n\nconst runtimeRequire = createRequire(import.meta.url);\n\
|
|
1
|
+
{"version":3,"file":"temporal.cjs","names":["createRequire"],"sources":["../src/temporal.ts"],"sourcesContent":["/// <reference types=\"temporal-spec/global\" preserve=\"true\" />\n\nimport { createRequire } from \"node:module\";\n\nconst runtimeRequire = createRequire(import.meta.url);\n\n// Native Temporal and both supported polyfills expose this shape; use the shared spec types instead of duplicating it.\ntype TemporalModule = typeof import(\"temporal-spec\");\nlet temporal: TemporalModule | undefined | false;\n\n/**\n * Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.\n *\n * This is useful while the joist-orm repo itself has both pre-Node 26, and post-Node 26\n * test coverage, b/c our CI test suite needs the same a) codegen output and b) test suites\n * to \"just work\" with either Node 24/25 or Node 26, which means they can't have an explicit\n * import to either `temporal-polyfill` or the `Temporal` global.\n *\n * This is exactly what Joist's internal temporal resolution was already working around, so\n * this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests\n * reuse the same abstraction.\n */\nexport const Temporal = new Proxy(\n {},\n {\n get(_target, property, receiver) {\n return Reflect.get(requireTemporal().Temporal, property, receiver);\n },\n },\n) as typeof globalThis.Temporal;\n\n/**\n * A type-only `Temporal` namespace that merges with the `const Temporal` above.\n *\n * The `const` is only a value, so using `Temporal.PlainDate` / `Temporal.ZonedDateTime` as a\n * type needs a namespace to resolve against. Node 26 has that as a global, but older Node\n * versions don't, so `temporal-spec/global` supplies the same global namespace as a fallback.\n */\nexport declare namespace Temporal {\n export type Instant = globalThis.Temporal.Instant;\n export type ZonedDateTime = globalThis.Temporal.ZonedDateTime;\n export type PlainDate = globalThis.Temporal.PlainDate;\n export type PlainTime = globalThis.Temporal.PlainTime;\n export type PlainDateTime = globalThis.Temporal.PlainDateTime;\n export type PlainYearMonth = globalThis.Temporal.PlainYearMonth;\n export type PlainMonthDay = globalThis.Temporal.PlainMonthDay;\n export type Duration = globalThis.Temporal.Duration;\n}\n\n/**\n * Conditionally/dynamically requires `temporal-polyfill`.\n *\n * We want to avoid directly importing/requiring `temporal-polyfill` because\n * it will introduce the dependency to all users of Joist.\n */\nexport function maybeRequireTemporal(): TemporalModule | undefined {\n // if we've already failed to find a temporal implementation before, early exit\n if (temporal === false) return undefined;\n // if we already required temporal, just return that\n if (temporal) return temporal;\n // use built in temporal if present\n if (\"Temporal\" in global && \"Intl\" in global) {\n temporal = {\n Temporal: global.Temporal as typeof globalThis.Temporal,\n toTemporalInstant: Date.prototype.toTemporalInstant,\n Intl: global.Intl,\n };\n return temporal;\n }\n // preferentially try to use temporal-polyfill\n try {\n temporal = runtimeRequire(\"temporal-polyfill\");\n return temporal as TemporalModule;\n } catch (e) {}\n // last resort, try to use @js-temporal/polyfill\n try {\n temporal = runtimeRequire(\"@js-temporal/polyfill\");\n return temporal as TemporalModule;\n } catch (e) {}\n // don't try to load temporal again\n temporal = false;\n return undefined;\n}\n\nexport function requireTemporal(): TemporalModule {\n const temporal = maybeRequireTemporal();\n if (!temporal) throw new Error(\"Unable to find a Temporal implementation\");\n return temporal;\n}\n"],"mappings":";;AAIA,MAAM,kBAAA,wBAAiBA,CAAAA,CAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAA6B;AAIpD,IAAI;;;;;;;;;;;;;AAcJ,MAAa,WAAW,IAAI,MAC1B,CAAC,GACD,EACE,IAAI,SAAS,UAAU,UAAU;CAC/B,OAAO,QAAQ,IAAI,gBAAgB,CAAC,CAAC,UAAU,UAAU,QAAQ;AACnE,EACF,CACF;;;;;;;AA0BA,SAAgB,uBAAmD;CAEjE,IAAI,aAAa,OAAO,OAAO,KAAA;CAE/B,IAAI,UAAU,OAAO;CAErB,IAAI,cAAc,UAAU,UAAU,QAAQ;EAC5C,WAAW;GACT,UAAU,OAAO;GACjB,mBAAmB,KAAK,UAAU;GAClC,MAAM,OAAO;EACf;EACA,OAAO;CACT;CAEA,IAAI;EACF,WAAW,eAAe,mBAAmB;EAC7C,OAAO;CACT,SAAS,GAAG,CAAC;CAEb,IAAI;EACF,WAAW,eAAe,uBAAuB;EACjD,OAAO;CACT,SAAS,GAAG,CAAC;CAEb,WAAW;AAEb;AAEA,SAAgB,kBAAkC;CAChD,MAAM,WAAW,qBAAqB;CACtC,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,0CAA0C;CACzE,OAAO;AACT"}
|
package/build/temporal.d.cts
CHANGED
|
@@ -1,23 +1,6 @@
|
|
|
1
1
|
/// <reference types="temporal-spec/global" preserve="true" />
|
|
2
2
|
//#region src/temporal.d.ts
|
|
3
|
-
type
|
|
4
|
-
Temporal: typeof globalThis.Temporal;
|
|
5
|
-
toTemporalInstant: typeof Date.prototype.toTemporalInstant;
|
|
6
|
-
Intl: typeof globalThis.Intl;
|
|
7
|
-
};
|
|
8
|
-
type TemporalConstructor<T> = {
|
|
9
|
-
[Symbol.hasInstance](value: unknown): value is T;
|
|
10
|
-
};
|
|
11
|
-
type TemporalGlobal = typeof globalThis.Temporal & {
|
|
12
|
-
Instant: typeof globalThis.Temporal.Instant & TemporalConstructor<globalThis.Temporal.Instant>;
|
|
13
|
-
ZonedDateTime: typeof globalThis.Temporal.ZonedDateTime & TemporalConstructor<globalThis.Temporal.ZonedDateTime>;
|
|
14
|
-
PlainDate: typeof globalThis.Temporal.PlainDate & TemporalConstructor<globalThis.Temporal.PlainDate>;
|
|
15
|
-
PlainTime: typeof globalThis.Temporal.PlainTime & TemporalConstructor<globalThis.Temporal.PlainTime>;
|
|
16
|
-
PlainDateTime: typeof globalThis.Temporal.PlainDateTime & TemporalConstructor<globalThis.Temporal.PlainDateTime>;
|
|
17
|
-
PlainYearMonth: typeof globalThis.Temporal.PlainYearMonth & TemporalConstructor<globalThis.Temporal.PlainYearMonth>;
|
|
18
|
-
PlainMonthDay: typeof globalThis.Temporal.PlainMonthDay & TemporalConstructor<globalThis.Temporal.PlainMonthDay>;
|
|
19
|
-
Duration: typeof globalThis.Temporal.Duration & TemporalConstructor<globalThis.Temporal.Duration>;
|
|
20
|
-
};
|
|
3
|
+
type TemporalModule = typeof import("temporal-spec");
|
|
21
4
|
/**
|
|
22
5
|
* Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.
|
|
23
6
|
*
|
|
@@ -30,7 +13,7 @@ type TemporalGlobal = typeof globalThis.Temporal & {
|
|
|
30
13
|
* this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests
|
|
31
14
|
* reuse the same abstraction.
|
|
32
15
|
*/
|
|
33
|
-
declare const Temporal:
|
|
16
|
+
declare const Temporal: typeof globalThis.Temporal;
|
|
34
17
|
/**
|
|
35
18
|
* A type-only `Temporal` namespace that merges with the `const Temporal` above.
|
|
36
19
|
*
|
|
@@ -54,8 +37,8 @@ declare namespace Temporal {
|
|
|
54
37
|
* We want to avoid directly importing/requiring `temporal-polyfill` because
|
|
55
38
|
* it will introduce the dependency to all users of Joist.
|
|
56
39
|
*/
|
|
57
|
-
declare function maybeRequireTemporal():
|
|
58
|
-
declare function requireTemporal():
|
|
40
|
+
declare function maybeRequireTemporal(): TemporalModule | undefined;
|
|
41
|
+
declare function requireTemporal(): TemporalModule;
|
|
59
42
|
//#endregion
|
|
60
43
|
export { Temporal, maybeRequireTemporal, requireTemporal };
|
|
61
44
|
//# sourceMappingURL=temporal.d.cts.map
|
package/build/temporal.d.cts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"temporal.d.cts","names":[],"sources":["../src/temporal.ts"],"mappings":";;
|
|
1
|
+
{"version":3,"file":"temporal.d.cts","names":[],"sources":["../src/temporal.ts"],"mappings":";;KAOK;;;;;;;;;;;;;cAeQ,iBAOD,WAAW;;;;;;;;kBASE;OACX,UAAU,WAAW,SAAS;OAC9B,gBAAgB,WAAW,SAAS;OACpC,YAAY,WAAW,SAAS;OAChC,YAAY,WAAW,SAAS;OAChC,gBAAgB,WAAW,SAAS;OACpC,iBAAiB,WAAW,SAAS;OACrC,gBAAgB,WAAW,SAAS;OACpC,WAAW,WAAW,SAAS;;;;;;;;iBAS7B,wBAAwB;iBA6BxB,mBAAmB"}
|
package/build/temporal.d.mts
CHANGED
|
@@ -1,23 +1,6 @@
|
|
|
1
1
|
/// <reference types="temporal-spec/global" preserve="true" />
|
|
2
2
|
//#region src/temporal.d.ts
|
|
3
|
-
type
|
|
4
|
-
Temporal: typeof globalThis.Temporal;
|
|
5
|
-
toTemporalInstant: typeof Date.prototype.toTemporalInstant;
|
|
6
|
-
Intl: typeof globalThis.Intl;
|
|
7
|
-
};
|
|
8
|
-
type TemporalConstructor<T> = {
|
|
9
|
-
[Symbol.hasInstance](value: unknown): value is T;
|
|
10
|
-
};
|
|
11
|
-
type TemporalGlobal = typeof globalThis.Temporal & {
|
|
12
|
-
Instant: typeof globalThis.Temporal.Instant & TemporalConstructor<globalThis.Temporal.Instant>;
|
|
13
|
-
ZonedDateTime: typeof globalThis.Temporal.ZonedDateTime & TemporalConstructor<globalThis.Temporal.ZonedDateTime>;
|
|
14
|
-
PlainDate: typeof globalThis.Temporal.PlainDate & TemporalConstructor<globalThis.Temporal.PlainDate>;
|
|
15
|
-
PlainTime: typeof globalThis.Temporal.PlainTime & TemporalConstructor<globalThis.Temporal.PlainTime>;
|
|
16
|
-
PlainDateTime: typeof globalThis.Temporal.PlainDateTime & TemporalConstructor<globalThis.Temporal.PlainDateTime>;
|
|
17
|
-
PlainYearMonth: typeof globalThis.Temporal.PlainYearMonth & TemporalConstructor<globalThis.Temporal.PlainYearMonth>;
|
|
18
|
-
PlainMonthDay: typeof globalThis.Temporal.PlainMonthDay & TemporalConstructor<globalThis.Temporal.PlainMonthDay>;
|
|
19
|
-
Duration: typeof globalThis.Temporal.Duration & TemporalConstructor<globalThis.Temporal.Duration>;
|
|
20
|
-
};
|
|
3
|
+
type TemporalModule = typeof import("temporal-spec");
|
|
21
4
|
/**
|
|
22
5
|
* Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.
|
|
23
6
|
*
|
|
@@ -30,7 +13,7 @@ type TemporalGlobal = typeof globalThis.Temporal & {
|
|
|
30
13
|
* this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests
|
|
31
14
|
* reuse the same abstraction.
|
|
32
15
|
*/
|
|
33
|
-
declare const Temporal:
|
|
16
|
+
declare const Temporal: typeof globalThis.Temporal;
|
|
34
17
|
/**
|
|
35
18
|
* A type-only `Temporal` namespace that merges with the `const Temporal` above.
|
|
36
19
|
*
|
|
@@ -54,8 +37,8 @@ declare namespace Temporal {
|
|
|
54
37
|
* We want to avoid directly importing/requiring `temporal-polyfill` because
|
|
55
38
|
* it will introduce the dependency to all users of Joist.
|
|
56
39
|
*/
|
|
57
|
-
declare function maybeRequireTemporal():
|
|
58
|
-
declare function requireTemporal():
|
|
40
|
+
declare function maybeRequireTemporal(): TemporalModule | undefined;
|
|
41
|
+
declare function requireTemporal(): TemporalModule;
|
|
59
42
|
//#endregion
|
|
60
43
|
export { Temporal, maybeRequireTemporal, requireTemporal };
|
|
61
44
|
//# sourceMappingURL=temporal.d.mts.map
|
package/build/temporal.d.mts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"temporal.d.mts","names":[],"sources":["../src/temporal.ts"],"mappings":";;
|
|
1
|
+
{"version":3,"file":"temporal.d.mts","names":[],"sources":["../src/temporal.ts"],"mappings":";;KAOK;;;;;;;;;;;;;cAeQ,iBAOD,WAAW;;;;;;;;kBASE;OACX,UAAU,WAAW,SAAS;OAC9B,gBAAgB,WAAW,SAAS;OACpC,YAAY,WAAW,SAAS;OAChC,YAAY,WAAW,SAAS;OAChC,gBAAgB,WAAW,SAAS;OACpC,iBAAiB,WAAW,SAAS;OACrC,gBAAgB,WAAW,SAAS;OACpC,WAAW,WAAW,SAAS;;;;;;;;iBAS7B,wBAAwB;iBA6BxB,mBAAmB"}
|
package/build/temporal.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"temporal.js","names":[],"sources":["../src/temporal.ts"],"sourcesContent":["/// <reference types=\"temporal-spec/global\" preserve=\"true\" />\n\nimport { createRequire } from \"node:module\";\n\nconst runtimeRequire = createRequire(import.meta.url);\n\
|
|
1
|
+
{"version":3,"file":"temporal.js","names":[],"sources":["../src/temporal.ts"],"sourcesContent":["/// <reference types=\"temporal-spec/global\" preserve=\"true\" />\n\nimport { createRequire } from \"node:module\";\n\nconst runtimeRequire = createRequire(import.meta.url);\n\n// Native Temporal and both supported polyfills expose this shape; use the shared spec types instead of duplicating it.\ntype TemporalModule = typeof import(\"temporal-spec\");\nlet temporal: TemporalModule | undefined | false;\n\n/**\n * Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.\n *\n * This is useful while the joist-orm repo itself has both pre-Node 26, and post-Node 26\n * test coverage, b/c our CI test suite needs the same a) codegen output and b) test suites\n * to \"just work\" with either Node 24/25 or Node 26, which means they can't have an explicit\n * import to either `temporal-polyfill` or the `Temporal` global.\n *\n * This is exactly what Joist's internal temporal resolution was already working around, so\n * this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests\n * reuse the same abstraction.\n */\nexport const Temporal = new Proxy(\n {},\n {\n get(_target, property, receiver) {\n return Reflect.get(requireTemporal().Temporal, property, receiver);\n },\n },\n) as typeof globalThis.Temporal;\n\n/**\n * A type-only `Temporal` namespace that merges with the `const Temporal` above.\n *\n * The `const` is only a value, so using `Temporal.PlainDate` / `Temporal.ZonedDateTime` as a\n * type needs a namespace to resolve against. Node 26 has that as a global, but older Node\n * versions don't, so `temporal-spec/global` supplies the same global namespace as a fallback.\n */\nexport declare namespace Temporal {\n export type Instant = globalThis.Temporal.Instant;\n export type ZonedDateTime = globalThis.Temporal.ZonedDateTime;\n export type PlainDate = globalThis.Temporal.PlainDate;\n export type PlainTime = globalThis.Temporal.PlainTime;\n export type PlainDateTime = globalThis.Temporal.PlainDateTime;\n export type PlainYearMonth = globalThis.Temporal.PlainYearMonth;\n export type PlainMonthDay = globalThis.Temporal.PlainMonthDay;\n export type Duration = globalThis.Temporal.Duration;\n}\n\n/**\n * Conditionally/dynamically requires `temporal-polyfill`.\n *\n * We want to avoid directly importing/requiring `temporal-polyfill` because\n * it will introduce the dependency to all users of Joist.\n */\nexport function maybeRequireTemporal(): TemporalModule | undefined {\n // if we've already failed to find a temporal implementation before, early exit\n if (temporal === false) return undefined;\n // if we already required temporal, just return that\n if (temporal) return temporal;\n // use built in temporal if present\n if (\"Temporal\" in global && \"Intl\" in global) {\n temporal = {\n Temporal: global.Temporal as typeof globalThis.Temporal,\n toTemporalInstant: Date.prototype.toTemporalInstant,\n Intl: global.Intl,\n };\n return temporal;\n }\n // preferentially try to use temporal-polyfill\n try {\n temporal = runtimeRequire(\"temporal-polyfill\");\n return temporal as TemporalModule;\n } catch (e) {}\n // last resort, try to use @js-temporal/polyfill\n try {\n temporal = runtimeRequire(\"@js-temporal/polyfill\");\n return temporal as TemporalModule;\n } catch (e) {}\n // don't try to load temporal again\n temporal = false;\n return undefined;\n}\n\nexport function requireTemporal(): TemporalModule {\n const temporal = maybeRequireTemporal();\n if (!temporal) throw new Error(\"Unable to find a Temporal implementation\");\n return temporal;\n}\n"],"mappings":";;AAIA,MAAM,iBAAiB,cAAc,YAAY,GAAG;AAIpD,IAAI;;;;;;;;;;;;;AAcJ,MAAa,WAAW,IAAI,MAC1B,CAAC,GACD,EACE,IAAI,SAAS,UAAU,UAAU;CAC/B,OAAO,QAAQ,IAAI,gBAAgB,CAAC,CAAC,UAAU,UAAU,QAAQ;AACnE,EACF,CACF;;;;;;;AA0BA,SAAgB,uBAAmD;CAEjE,IAAI,aAAa,OAAO,OAAO,KAAA;CAE/B,IAAI,UAAU,OAAO;CAErB,IAAI,cAAc,UAAU,UAAU,QAAQ;EAC5C,WAAW;GACT,UAAU,OAAO;GACjB,mBAAmB,KAAK,UAAU;GAClC,MAAM,OAAO;EACf;EACA,OAAO;CACT;CAEA,IAAI;EACF,WAAW,eAAe,mBAAmB;EAC7C,OAAO;CACT,SAAS,GAAG,CAAC;CAEb,IAAI;EACF,WAAW,eAAe,uBAAuB;EACjD,OAAO;CACT,SAAS,GAAG,CAAC;CAEb,WAAW;AAEb;AAEA,SAAgB,kBAAkC;CAChD,MAAM,WAAW,qBAAqB;CACtC,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,0CAA0C;CACzE,OAAO;AACT"}
|
|
@@ -48,7 +48,7 @@ const plainDateTimeMapper = t ? {
|
|
|
48
48
|
*/
|
|
49
49
|
const zonedDateTimeMapper = t ? {
|
|
50
50
|
fromDb: (value) => {
|
|
51
|
-
if (value
|
|
51
|
+
if (typeof value !== "string") return value;
|
|
52
52
|
const [offset] = value.match(/([+-]\d{2}(?::?\d{2})?)$/) ?? [];
|
|
53
53
|
return t.ZonedDateTime.from(`${value}[${!offset || /^\+00(:?00)?$/.test(offset) ? "UTC" : offset}]`);
|
|
54
54
|
},
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"temporalMappers.cjs","names":["maybeRequireTemporal","fail"],"sources":["../src/temporalMappers.ts"],"sourcesContent":["import { type CustomSerde } from \"./serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"./temporal.ts\";\nimport { fail } from \"./utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n fromDb: () => fail(\"Temporal not available\"),\n toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n toDb: (pt) => pt.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n ? {\n // Text values look like `2018-01-01 10:00:00`\n fromDb: (value: string | Temporal.PlainDateTime) =>\n value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone. This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically. If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n ? {\n // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n // instances (lazy queries construct ZonedDateTimes directly) pass through\n fromDb: (value: string | Temporal.ZonedDateTime) => {\n if (value
|
|
1
|
+
{"version":3,"file":"temporalMappers.cjs","names":["maybeRequireTemporal","fail"],"sources":["../src/temporalMappers.ts"],"sourcesContent":["import { type CustomSerde } from \"./serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"./temporal.ts\";\nimport { fail } from \"./utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n fromDb: () => fail(\"Temporal not available\"),\n toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n toDb: (pt) => pt.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n ? {\n // Text values look like `2018-01-01 10:00:00`\n fromDb: (value: string | Temporal.PlainDateTime) =>\n value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone. This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically. If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n ? {\n // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n // instances (lazy queries construct ZonedDateTimes directly) pass through\n fromDb: (value: string | Temporal.ZonedDateTime) => {\n if (typeof value !== \"string\") return value;\n const [offset] = value.match(/([+-]\\d{2}(?::?\\d{2})?)$/) ?? [];\n return t.ZonedDateTime.from(`${value}[${!offset || /^\\+00(:?00)?$/.test(offset) ? \"UTC\" : offset}]`);\n },\n // Match a PG `TIMESTAMPTZ` input format, i.e. \"2021-01-01T12:00:00-05:00\"\n toDb: (zdt) => zdt.toString({ timeZoneName: \"never\" }),\n }\n : temporalNotAvailable;\n"],"mappings":";;;;;AAIA,MAAM,EAAE,UAAU,MAAMA,iBAAAA,qBAAqB,KAAK,CAAC;AACnD,MAAM,uBAAuB;CAC3B,cAAcC,cAAAA,KAAK,wBAAwB;CAC3C,YAAYA,cAAAA,KAAK,wBAAwB;AAC3C;;;;;;;AAQA,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;AAGJ,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,OAAO,GAAG,SAAS;AAC5B,IACA;;;;;AAMJ,MAAa,sBAAmE,IAC5E;CAEE,SAAS,UACP,iBAAiB,EAAE,gBAAgB,QAAQ,EAAE,cAAc,KAAK,KAAK;CACvE,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;;;;;;;;;;;;;;;AAiBJ,MAAa,sBAAmE,IAC5E;CAGE,SAAS,UAA2C;EAClD,IAAI,OAAO,UAAU,UAAU,OAAO;EACtC,MAAM,CAAC,UAAU,MAAM,MAAM,0BAA0B,KAAK,CAAC;EAC7D,OAAO,EAAE,cAAc,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,gBAAgB,KAAK,MAAM,IAAI,QAAQ,OAAO,EAAE;CACrG;CAEA,OAAO,QAAQ,IAAI,SAAS,EAAE,cAAc,QAAQ,CAAC;AACvD,IACA"}
|
package/build/temporalMappers.js
CHANGED
|
@@ -47,7 +47,7 @@ const plainDateTimeMapper = t ? {
|
|
|
47
47
|
*/
|
|
48
48
|
const zonedDateTimeMapper = t ? {
|
|
49
49
|
fromDb: (value) => {
|
|
50
|
-
if (value
|
|
50
|
+
if (typeof value !== "string") return value;
|
|
51
51
|
const [offset] = value.match(/([+-]\d{2}(?::?\d{2})?)$/) ?? [];
|
|
52
52
|
return t.ZonedDateTime.from(`${value}[${!offset || /^\+00(:?00)?$/.test(offset) ? "UTC" : offset}]`);
|
|
53
53
|
},
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"temporalMappers.js","names":[],"sources":["../src/temporalMappers.ts"],"sourcesContent":["import { type CustomSerde } from \"./serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"./temporal.ts\";\nimport { fail } from \"./utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n fromDb: () => fail(\"Temporal not available\"),\n toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n toDb: (pt) => pt.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n ? {\n // Text values look like `2018-01-01 10:00:00`\n fromDb: (value: string | Temporal.PlainDateTime) =>\n value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone. This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically. If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n ? {\n // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n // instances (lazy queries construct ZonedDateTimes directly) pass through\n fromDb: (value: string | Temporal.ZonedDateTime) => {\n if (value
|
|
1
|
+
{"version":3,"file":"temporalMappers.js","names":[],"sources":["../src/temporalMappers.ts"],"sourcesContent":["import { type CustomSerde } from \"./serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"./temporal.ts\";\nimport { fail } from \"./utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n fromDb: () => fail(\"Temporal not available\"),\n toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n ? {\n fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n toDb: (pt) => pt.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n ? {\n // Text values look like `2018-01-01 10:00:00`\n fromDb: (value: string | Temporal.PlainDateTime) =>\n value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n toDb: (p) => p.toString(),\n }\n : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone. This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically. If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n ? {\n // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n // instances (lazy queries construct ZonedDateTimes directly) pass through\n fromDb: (value: string | Temporal.ZonedDateTime) => {\n if (typeof value !== \"string\") return value;\n const [offset] = value.match(/([+-]\\d{2}(?::?\\d{2})?)$/) ?? [];\n return t.ZonedDateTime.from(`${value}[${!offset || /^\\+00(:?00)?$/.test(offset) ? \"UTC\" : offset}]`);\n },\n // Match a PG `TIMESTAMPTZ` input format, i.e. \"2021-01-01T12:00:00-05:00\"\n toDb: (zdt) => zdt.toString({ timeZoneName: \"never\" }),\n }\n : temporalNotAvailable;\n"],"mappings":";;;;AAIA,MAAM,EAAE,UAAU,MAAM,qBAAqB,KAAK,CAAC;AACnD,MAAM,uBAAuB;CAC3B,cAAc,KAAK,wBAAwB;CAC3C,YAAY,KAAK,wBAAwB;AAC3C;;;;;;;AAQA,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;AAGJ,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,OAAO,GAAG,SAAS;AAC5B,IACA;;;;;AAMJ,MAAa,sBAAmE,IAC5E;CAEE,SAAS,UACP,iBAAiB,EAAE,gBAAgB,QAAQ,EAAE,cAAc,KAAK,KAAK;CACvE,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;;;;;;;;;;;;;;;AAiBJ,MAAa,sBAAmE,IAC5E;CAGE,SAAS,UAA2C;EAClD,IAAI,OAAO,UAAU,UAAU,OAAO;EACtC,MAAM,CAAC,UAAU,MAAM,MAAM,0BAA0B,KAAK,CAAC;EAC7D,OAAO,EAAE,cAAc,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,gBAAgB,KAAK,MAAM,IAAI,QAAQ,OAAO,EAAE;CACrG;CAEA,OAAO,QAAQ,IAAI,SAAS,EAAE,cAAc,QAAQ,CAAC;AACvD,IACA"}
|
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.45",
|
|
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.45"
|
|
46
46
|
},
|
|
47
47
|
"dependencies": {
|
|
48
48
|
"ansis": "^4.3.1",
|