@postxl/generator 1.3.7 → 1.4.0
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/dist/utils/lockfile.d.ts +26 -1
- package/dist/utils/lockfile.js +37 -10
- package/dist/utils/sync.d.ts +26 -21
- package/dist/utils/sync.js +61 -27
- package/package.json +2 -2
package/dist/utils/lockfile.d.ts
CHANGED
|
@@ -1,7 +1,32 @@
|
|
|
1
1
|
import { z } from 'zod';
|
|
2
|
+
import { Checksum } from './checksum';
|
|
2
3
|
import { VirtualFileSystem } from './vfs.class';
|
|
3
|
-
|
|
4
|
+
/**
|
|
5
|
+
* Sentinel value used in the lock file to mark a file as "permanently ejected".
|
|
6
|
+
*
|
|
7
|
+
* When a lock file entry's value equals this sentinel, the sync process will
|
|
8
|
+
* not touch the file on disk (no writes, no deletes, no merge conflicts) and
|
|
9
|
+
* will preserve the sentinel in future lock file writes — regardless of the
|
|
10
|
+
* `force` flag.
|
|
11
|
+
*
|
|
12
|
+
* Users mark a file as ejected by manually replacing its checksum in
|
|
13
|
+
* `postxl-lock.json` with the string `"ejected"`.
|
|
14
|
+
*
|
|
15
|
+
* Safety: all checksums produced by {@link calculateChecksum} are SHA-256
|
|
16
|
+
* hex digests (64 lowercase characters in `[0-9a-f]`), so they can never
|
|
17
|
+
* collide with the plain-English string `"ejected"`. If the checksum format
|
|
18
|
+
* ever changes, update this sentinel (or its shape) accordingly.
|
|
19
|
+
*/
|
|
20
|
+
export declare const EJECTED_SENTINEL: "ejected";
|
|
21
|
+
export type EjectedSentinel = typeof EJECTED_SENTINEL;
|
|
22
|
+
/**
|
|
23
|
+
* A value stored against a path in the lock file: either the generated file's
|
|
24
|
+
* checksum, or the {@link EJECTED_SENTINEL} marking the file as permanently ejected.
|
|
25
|
+
*/
|
|
26
|
+
export type LockEntry = Checksum | EjectedSentinel;
|
|
27
|
+
declare const zLockFile: z.ZodPipe<z.ZodRecord<z.core.$ZodBranded<z.ZodString, "PXL.PosixPath", "out">, z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "PXL.Checksum", "out">, z.ZodLiteral<"ejected">]>>, z.ZodTransform<Map<string & z.core.$brand<"PXL.PosixPath">, LockEntry>, Record<string & z.core.$brand<"PXL.PosixPath">, (string & z.core.$brand<"PXL.Checksum">) | "ejected">>>;
|
|
4
28
|
type LockFile = z.infer<typeof zLockFile>;
|
|
29
|
+
export declare function isEjected(entry: LockEntry | undefined): entry is EjectedSentinel;
|
|
5
30
|
export declare function writeLockFile(lockFilePath: string, vfs: VirtualFileSystem): Promise<void>;
|
|
6
31
|
export declare function readLockFile(lockFilePath: string): Promise<LockFile | undefined>;
|
|
7
32
|
export {};
|
package/dist/utils/lockfile.js
CHANGED
|
@@ -33,26 +33,53 @@ var __importStar = (this && this.__importStar) || (function () {
|
|
|
33
33
|
};
|
|
34
34
|
})();
|
|
35
35
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
36
|
+
exports.EJECTED_SENTINEL = void 0;
|
|
37
|
+
exports.isEjected = isEjected;
|
|
36
38
|
exports.writeLockFile = writeLockFile;
|
|
37
39
|
exports.readLockFile = readLockFile;
|
|
38
40
|
const fs = __importStar(require("fs/promises"));
|
|
39
41
|
const zod_1 = require("zod");
|
|
40
42
|
const checksum_1 = require("./checksum");
|
|
41
43
|
const path_1 = require("./path");
|
|
44
|
+
/**
|
|
45
|
+
* Sentinel value used in the lock file to mark a file as "permanently ejected".
|
|
46
|
+
*
|
|
47
|
+
* When a lock file entry's value equals this sentinel, the sync process will
|
|
48
|
+
* not touch the file on disk (no writes, no deletes, no merge conflicts) and
|
|
49
|
+
* will preserve the sentinel in future lock file writes — regardless of the
|
|
50
|
+
* `force` flag.
|
|
51
|
+
*
|
|
52
|
+
* Users mark a file as ejected by manually replacing its checksum in
|
|
53
|
+
* `postxl-lock.json` with the string `"ejected"`.
|
|
54
|
+
*
|
|
55
|
+
* Safety: all checksums produced by {@link calculateChecksum} are SHA-256
|
|
56
|
+
* hex digests (64 lowercase characters in `[0-9a-f]`), so they can never
|
|
57
|
+
* collide with the plain-English string `"ejected"`. If the checksum format
|
|
58
|
+
* ever changes, update this sentinel (or its shape) accordingly.
|
|
59
|
+
*/
|
|
60
|
+
exports.EJECTED_SENTINEL = 'ejected';
|
|
61
|
+
const zLockEntry = zod_1.z.union([checksum_1.zChecksum, zod_1.z.literal(exports.EJECTED_SENTINEL)]);
|
|
42
62
|
const zLockFile = zod_1.z
|
|
43
|
-
.record(path_1.zPosixPath,
|
|
63
|
+
.record(path_1.zPosixPath, zLockEntry)
|
|
44
64
|
.transform((val) => new Map(Object.entries(val).filter((entry) => entry[1] !== undefined)));
|
|
65
|
+
function isEjected(entry) {
|
|
66
|
+
return entry === exports.EJECTED_SENTINEL;
|
|
67
|
+
}
|
|
45
68
|
async function writeLockFile(lockFilePath, vfs) {
|
|
46
69
|
const newLockFileMap = await vfsToLockFile(vfs);
|
|
47
|
-
|
|
48
|
-
if (
|
|
49
|
-
const
|
|
50
|
-
|
|
51
|
-
//
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
70
|
+
const existingLockFile = await readLockFile(lockFilePath);
|
|
71
|
+
if (existingLockFile) {
|
|
72
|
+
for (const [filePath, entry] of existingLockFile) {
|
|
73
|
+
// Ejected entries are sticky: always preserve them, even if the generator
|
|
74
|
+
// still produces the file (the VFS checksum would otherwise clobber the sentinel).
|
|
75
|
+
if (isEjected(entry)) {
|
|
76
|
+
newLockFileMap.set(filePath, exports.EJECTED_SENTINEL);
|
|
77
|
+
continue;
|
|
78
|
+
}
|
|
79
|
+
// If a file pattern filter is set, keep all entries from the existing lock file
|
|
80
|
+
// that don't match the current filter (they were out of scope for this run).
|
|
81
|
+
if (vfs.filePattern && !vfs.matchesPattern(filePath) && !newLockFileMap.has(filePath)) {
|
|
82
|
+
newLockFileMap.set(filePath, entry);
|
|
56
83
|
}
|
|
57
84
|
}
|
|
58
85
|
}
|
package/dist/utils/sync.d.ts
CHANGED
|
@@ -22,36 +22,39 @@
|
|
|
22
22
|
*
|
|
23
23
|
* Thus, we have the following potential states for each file:
|
|
24
24
|
* - virtual: `empty` | `Hash1` (hash sum from current generation)
|
|
25
|
-
* - lock: `empty` | `Hash1` | `Hash0` (hash sum from prior generation)
|
|
25
|
+
* - lock: `empty` | `Hash1` | `Hash0` | `ejected` (hash sum from prior generation, or the "permanently ejected" sentinel)
|
|
26
26
|
* - disk: `empty` | `Hash1` | `Hash0` | `HashX` (different hash sum from disk)
|
|
27
27
|
*
|
|
28
28
|
* The below table shows all possible combinations of these states - and the resulting action that needs to be performed:
|
|
29
29
|
*
|
|
30
|
-
*
|
|
31
|
-
* | VFS | Lock
|
|
32
|
-
*
|
|
33
|
-
* | Hash1 | Hash1
|
|
34
|
-
* | Hash1 | Hash1
|
|
35
|
-
* | Hash1 | Hash1
|
|
36
|
-
* | Hash1 | Hash0
|
|
37
|
-
* | Hash1 | Hash0
|
|
38
|
-
* | Hash1 | Hash0
|
|
39
|
-
* | Hash1 | Hash0
|
|
40
|
-
* | Hash1 | empty
|
|
41
|
-
* | Hash1 | empty
|
|
42
|
-
* | Hash1 | empty
|
|
43
|
-
*
|
|
44
|
-
* | empty | Hash0
|
|
45
|
-
* | empty | Hash0
|
|
46
|
-
* | empty | Hash0
|
|
47
|
-
* | empty | empty
|
|
48
|
-
* | empty | empty
|
|
49
|
-
*
|
|
30
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
31
|
+
* | VFS | Lock | Disk | Description | Action on disk |
|
|
32
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
33
|
+
* | Hash1 | Hash1 | Hash1 | Unchanged | No action |
|
|
34
|
+
* | Hash1 | Hash1 | HashX/0 | Ejected | No action |
|
|
35
|
+
* | Hash1 | Hash1 | empty | Deleted on disk | No action |
|
|
36
|
+
* | Hash1 | Hash0 | Hash1 | Corrupt lock file? | No action |
|
|
37
|
+
* | Hash1 | Hash0 | Hash0 | Changed, not ejected | Update to VFS version |
|
|
38
|
+
* | Hash1 | Hash0 | HashX | Changed, ejected | Create "merge conflict"(2)|
|
|
39
|
+
* | Hash1 | Hash0 | empty | Changed, deleted on disk | Write file (1) |
|
|
40
|
+
* | Hash1 | empty | Hash1 | Corrupt lock file? | No action |
|
|
41
|
+
* | Hash1 | empty | HashX/0 | File ejected, corrupt lock file | Create "merge conflict"(2)|
|
|
42
|
+
* | Hash1 | empty | empty | Newly generated | Write file |
|
|
43
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
44
|
+
* | empty | Hash0 | Hash0 | Unejected file | Delete file |
|
|
45
|
+
* | empty | Hash0 | HashX | Ejected file was deleted | Delete file (3) |
|
|
46
|
+
* | empty | Hash0 | empty | File was manually deleted first | No action |
|
|
47
|
+
* | empty | empty | HashX | Manual file | No action |
|
|
48
|
+
* | empty | empty | empty | Cannot occur | |
|
|
49
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
50
|
+
* | * | ejected | * | Permanently ejected (4) | No action (even in force) |
|
|
51
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
50
52
|
*
|
|
51
53
|
* Notes:
|
|
52
54
|
* (1) In case the file was deleted on disk and changed between the last generation and the current generation, we will write the file to disk. The developer can decide to keep the "restored" file or not. Next time generator runs, it will not be regenerated, as lock file hashes match.
|
|
53
55
|
* (2) In case the file was ejected and changed between the last generation and the current generation, we will overwrite the file on disk - with git "merge conflict" markers. The developer must then decide how to resolve the conflicts.
|
|
54
56
|
* (3) In case the file was deleted by the generator but ejected by the developer, we will delete the file from disk. The developer can decide to revert the deletion or not. Next time generator runs, it will not be regenerated, as lock file hashes match.
|
|
57
|
+
* (4) Permanently ejected files are marked by replacing the checksum in `postxl-lock.json` with the sentinel string `"ejected"`. The sync process short-circuits for these paths: the disk file is never written, never deleted, and never checked for merge-conflict markers. The sentinel is sticky — it is always preserved in subsequent lock file writes, regardless of whether the generator still produces the file. Even `force: true` respects the sentinel. To un-eject a file, delete the `"ejected"` entry from the lock file (and optionally also delete the file on disk if you want it freshly generated); the next run will treat it as `L:empty` and regenerate (possibly with a merge conflict if the disk file differs).
|
|
55
58
|
*
|
|
56
59
|
*/
|
|
57
60
|
import { Result, TypedError } from '@postxl/utils';
|
|
@@ -112,6 +115,8 @@ type FileState = {
|
|
|
112
115
|
} | {
|
|
113
116
|
state: 'hash';
|
|
114
117
|
hash: Checksum;
|
|
118
|
+
} | {
|
|
119
|
+
state: 'ejected';
|
|
115
120
|
};
|
|
116
121
|
type FileStateWithContent = {
|
|
117
122
|
state: 'empty';
|
package/dist/utils/sync.js
CHANGED
|
@@ -23,36 +23,39 @@
|
|
|
23
23
|
*
|
|
24
24
|
* Thus, we have the following potential states for each file:
|
|
25
25
|
* - virtual: `empty` | `Hash1` (hash sum from current generation)
|
|
26
|
-
* - lock: `empty` | `Hash1` | `Hash0` (hash sum from prior generation)
|
|
26
|
+
* - lock: `empty` | `Hash1` | `Hash0` | `ejected` (hash sum from prior generation, or the "permanently ejected" sentinel)
|
|
27
27
|
* - disk: `empty` | `Hash1` | `Hash0` | `HashX` (different hash sum from disk)
|
|
28
28
|
*
|
|
29
29
|
* The below table shows all possible combinations of these states - and the resulting action that needs to be performed:
|
|
30
30
|
*
|
|
31
|
-
*
|
|
32
|
-
* | VFS | Lock
|
|
33
|
-
*
|
|
34
|
-
* | Hash1 | Hash1
|
|
35
|
-
* | Hash1 | Hash1
|
|
36
|
-
* | Hash1 | Hash1
|
|
37
|
-
* | Hash1 | Hash0
|
|
38
|
-
* | Hash1 | Hash0
|
|
39
|
-
* | Hash1 | Hash0
|
|
40
|
-
* | Hash1 | Hash0
|
|
41
|
-
* | Hash1 | empty
|
|
42
|
-
* | Hash1 | empty
|
|
43
|
-
* | Hash1 | empty
|
|
44
|
-
*
|
|
45
|
-
* | empty | Hash0
|
|
46
|
-
* | empty | Hash0
|
|
47
|
-
* | empty | Hash0
|
|
48
|
-
* | empty | empty
|
|
49
|
-
* | empty | empty
|
|
50
|
-
*
|
|
31
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
32
|
+
* | VFS | Lock | Disk | Description | Action on disk |
|
|
33
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
34
|
+
* | Hash1 | Hash1 | Hash1 | Unchanged | No action |
|
|
35
|
+
* | Hash1 | Hash1 | HashX/0 | Ejected | No action |
|
|
36
|
+
* | Hash1 | Hash1 | empty | Deleted on disk | No action |
|
|
37
|
+
* | Hash1 | Hash0 | Hash1 | Corrupt lock file? | No action |
|
|
38
|
+
* | Hash1 | Hash0 | Hash0 | Changed, not ejected | Update to VFS version |
|
|
39
|
+
* | Hash1 | Hash0 | HashX | Changed, ejected | Create "merge conflict"(2)|
|
|
40
|
+
* | Hash1 | Hash0 | empty | Changed, deleted on disk | Write file (1) |
|
|
41
|
+
* | Hash1 | empty | Hash1 | Corrupt lock file? | No action |
|
|
42
|
+
* | Hash1 | empty | HashX/0 | File ejected, corrupt lock file | Create "merge conflict"(2)|
|
|
43
|
+
* | Hash1 | empty | empty | Newly generated | Write file |
|
|
44
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
45
|
+
* | empty | Hash0 | Hash0 | Unejected file | Delete file |
|
|
46
|
+
* | empty | Hash0 | HashX | Ejected file was deleted | Delete file (3) |
|
|
47
|
+
* | empty | Hash0 | empty | File was manually deleted first | No action |
|
|
48
|
+
* | empty | empty | HashX | Manual file | No action |
|
|
49
|
+
* | empty | empty | empty | Cannot occur | |
|
|
50
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
51
|
+
* | * | ejected | * | Permanently ejected (4) | No action (even in force) |
|
|
52
|
+
* |-------|---------|---------|---------------------------------|---------------------------|
|
|
51
53
|
*
|
|
52
54
|
* Notes:
|
|
53
55
|
* (1) In case the file was deleted on disk and changed between the last generation and the current generation, we will write the file to disk. The developer can decide to keep the "restored" file or not. Next time generator runs, it will not be regenerated, as lock file hashes match.
|
|
54
56
|
* (2) In case the file was ejected and changed between the last generation and the current generation, we will overwrite the file on disk - with git "merge conflict" markers. The developer must then decide how to resolve the conflicts.
|
|
55
57
|
* (3) In case the file was deleted by the generator but ejected by the developer, we will delete the file from disk. The developer can decide to revert the deletion or not. Next time generator runs, it will not be regenerated, as lock file hashes match.
|
|
58
|
+
* (4) Permanently ejected files are marked by replacing the checksum in `postxl-lock.json` with the sentinel string `"ejected"`. The sync process short-circuits for these paths: the disk file is never written, never deleted, and never checked for merge-conflict markers. The sentinel is sticky — it is always preserved in subsequent lock file writes, regardless of whether the generator still produces the file. Even `force: true` respects the sentinel. To un-eject a file, delete the `"ejected"` entry from the lock file (and optionally also delete the file on disk if you want it freshly generated); the next run will treat it as `L:empty` and regenerate (possibly with a merge conflict if the disk file differs).
|
|
56
59
|
*
|
|
57
60
|
*/
|
|
58
61
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
@@ -140,13 +143,25 @@ async function sync({ vfs, lockFilePath, diskFilePath, force }) {
|
|
|
140
143
|
files: {},
|
|
141
144
|
};
|
|
142
145
|
for (const [filePath, inputState] of files) {
|
|
143
|
-
const
|
|
146
|
+
const { virtual, lock, disk } = inputState;
|
|
147
|
+
// Permanently ejected files (marked with the "ejected" sentinel in the lock file)
|
|
148
|
+
// are skipped entirely: we never write, delete, or inspect them, regardless of `force`.
|
|
149
|
+
if (isEjectedFileState(lock)) {
|
|
150
|
+
result.files[filePath] = {
|
|
151
|
+
action: { type: 'NoAction' },
|
|
152
|
+
inputState,
|
|
153
|
+
actionResult: utils_1.Result.ok(undefined),
|
|
154
|
+
isEjected: true,
|
|
155
|
+
};
|
|
156
|
+
continue;
|
|
157
|
+
}
|
|
158
|
+
const [action, isEjectedFile] = determineActionState({ virtual, lock, disk }, force);
|
|
144
159
|
const task = limit(async () => {
|
|
145
160
|
const actionResult = await executeAction(Path.join(diskPathNormalized, filePath), action);
|
|
146
161
|
if (actionResult.isErr()) {
|
|
147
162
|
result.errors.push(actionResult.unwrapErr());
|
|
148
163
|
}
|
|
149
|
-
result.files[filePath] = { action, inputState, actionResult, isEjected };
|
|
164
|
+
result.files[filePath] = { action, inputState, actionResult, isEjected: isEjectedFile };
|
|
150
165
|
});
|
|
151
166
|
tasks.push(task);
|
|
152
167
|
}
|
|
@@ -165,7 +180,12 @@ const validFilesWithMergeConflictMarkers = new Set([
|
|
|
165
180
|
*/
|
|
166
181
|
function findFilesWithMergeConflicts(files) {
|
|
167
182
|
const filesWithConflicts = [];
|
|
168
|
-
for (const [filePath, { disk }] of files) {
|
|
183
|
+
for (const [filePath, { disk, lock }] of files) {
|
|
184
|
+
// Permanently ejected files are fully owned by the developer — we must not
|
|
185
|
+
// fail generation because their content happens to contain marker-like strings.
|
|
186
|
+
if (isEjectedFileState(lock)) {
|
|
187
|
+
continue;
|
|
188
|
+
}
|
|
169
189
|
if (disk.state === 'hash' &&
|
|
170
190
|
(0, merge_conflict_1.hasMergeConflictMarkers)(disk.content) &&
|
|
171
191
|
!validFilesWithMergeConflictMarkers.has(filePath)) {
|
|
@@ -174,11 +194,16 @@ function findFilesWithMergeConflicts(files) {
|
|
|
174
194
|
}
|
|
175
195
|
return filesWithConflicts;
|
|
176
196
|
}
|
|
197
|
+
/** Narrows a {@link FileState} to the `ejected` variant. Used to keep lock-level and file-state-level checks consistent. */
|
|
198
|
+
function isEjectedFileState(state) {
|
|
199
|
+
return state.state === 'ejected';
|
|
200
|
+
}
|
|
177
201
|
function getChecksum(file) {
|
|
178
202
|
switch (file.state) {
|
|
179
203
|
case 'hash':
|
|
180
204
|
return file.hash;
|
|
181
205
|
case 'empty':
|
|
206
|
+
case 'ejected':
|
|
182
207
|
return undefined;
|
|
183
208
|
default:
|
|
184
209
|
throw new utils_1.ExhaustiveSwitchCheck(file);
|
|
@@ -228,6 +253,15 @@ async function getDiskFileState(diskFilePath) {
|
|
|
228
253
|
}
|
|
229
254
|
return { state: 'empty' };
|
|
230
255
|
}
|
|
256
|
+
function lockEntryToFileState(entry) {
|
|
257
|
+
if (entry === undefined) {
|
|
258
|
+
return { state: 'empty' };
|
|
259
|
+
}
|
|
260
|
+
if ((0, lockfile_1.isEjected)(entry)) {
|
|
261
|
+
return { state: 'ejected' };
|
|
262
|
+
}
|
|
263
|
+
return { state: 'hash', hash: entry };
|
|
264
|
+
}
|
|
231
265
|
async function getFilesStates({ vfs, lockFilePath, diskFilePath, }) {
|
|
232
266
|
const lockFile = await (0, lockfile_1.readLockFile)(lockFilePath);
|
|
233
267
|
const files = new Map();
|
|
@@ -236,7 +270,7 @@ async function getFilesStates({ vfs, lockFilePath, diskFilePath, }) {
|
|
|
236
270
|
for (const [filePath, content] of vfs.files) {
|
|
237
271
|
const virtual = { state: 'hash', hash: await (0, checksum_1.calculateChecksum)(content), content };
|
|
238
272
|
const path = filePath;
|
|
239
|
-
const lock = lockFile?.
|
|
273
|
+
const lock = lockEntryToFileState(lockFile?.get(path));
|
|
240
274
|
const disk = await getDiskFileState(Path.join(diskPathNormalized, path));
|
|
241
275
|
files.set(path, { virtual, lock, disk });
|
|
242
276
|
}
|
|
@@ -244,7 +278,7 @@ async function getFilesStates({ vfs, lockFilePath, diskFilePath, }) {
|
|
|
244
278
|
// However, if the VFS has a file pattern filter, we should only consider lock file entries that match the pattern.
|
|
245
279
|
if (lockFile) {
|
|
246
280
|
const virtual = { state: 'empty' };
|
|
247
|
-
for (const [filePath,
|
|
281
|
+
for (const [filePath, entry] of lockFile) {
|
|
248
282
|
if (files.has(filePath)) {
|
|
249
283
|
continue;
|
|
250
284
|
}
|
|
@@ -252,7 +286,7 @@ async function getFilesStates({ vfs, lockFilePath, diskFilePath, }) {
|
|
|
252
286
|
if (!vfs.matchesPattern(filePath)) {
|
|
253
287
|
continue;
|
|
254
288
|
}
|
|
255
|
-
const lock =
|
|
289
|
+
const lock = lockEntryToFileState(entry);
|
|
256
290
|
const disk = await getDiskFileState(Path.join(diskPathNormalized, filePath));
|
|
257
291
|
files.set(filePath, { virtual, lock, disk });
|
|
258
292
|
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@postxl/generator",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.4.0",
|
|
4
4
|
"description": "Core package that orchestrates the code generation of a PXL project",
|
|
5
5
|
"main": "./dist/index.js",
|
|
6
6
|
"module": "./dist/index.js",
|
|
@@ -46,7 +46,7 @@
|
|
|
46
46
|
"jszip": "3.10.1",
|
|
47
47
|
"minimatch": "^10.2.2",
|
|
48
48
|
"p-limit": "3.1.0",
|
|
49
|
-
"@postxl/schema": "^1.
|
|
49
|
+
"@postxl/schema": "^1.9.0",
|
|
50
50
|
"@postxl/utils": "^1.4.0"
|
|
51
51
|
},
|
|
52
52
|
"devDependencies": {
|