packtory 0.0.1

package/config/config.d.ts

@@ -0,0 +1,470 @@
+import { type Schema } from '@effect/schema/Schema';
+import { type NoExpand } from './base-validations.js';
+export declare const packtoryConfigSchema: Schema<{
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly packages: readonly [{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+    readonly commonPackageSettings?: {
+        readonly sourcesFolder?: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+} | {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly commonPackageSettings: {
+        readonly sourcesFolder: string;
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+    readonly packages: readonly [{
+        readonly sourcesFolder?: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly sourcesFolder?: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+} | {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly commonPackageSettings: {
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly sourcesFolder?: string;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+    readonly packages: readonly [{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+} | {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly commonPackageSettings: {
+        readonly sourcesFolder: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+    readonly packages: readonly [{
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly sourcesFolder?: string;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly sourcesFolder?: string;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+}, {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly packages: readonly [{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+    readonly commonPackageSettings?: {
+        readonly sourcesFolder?: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+} | {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly commonPackageSettings: {
+        readonly sourcesFolder: string;
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+    readonly packages: readonly [{
+        readonly sourcesFolder?: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly sourcesFolder?: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+} | {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly commonPackageSettings: {
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly sourcesFolder?: string;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+    readonly packages: readonly [{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly sourcesFolder: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+} | {
+    readonly registrySettings: import("./registry-settings.js").RegistrySettings;
+    readonly commonPackageSettings: {
+        readonly sourcesFolder: string;
+        readonly mainPackageJson?: import("./package-json.js").MainPackageJson;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+    };
+    readonly packages: readonly [{
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly sourcesFolder?: string;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }, ...{
+        readonly mainPackageJson: import("./package-json.js").MainPackageJson;
+        readonly sourcesFolder?: string;
+        readonly includeSourceMapFiles?: boolean;
+        readonly additionalFiles?: readonly import("./additional-files.js").AdditionalFileDescription[];
+        readonly additionalPackageJsonAttributes?: {
+            readonly [x: string]: import("type-fest").JsonValue;
+        };
+        readonly entryPoints: readonly [import("./entry-point.js").EntryPoint, ...import("./entry-point.js").EntryPoint[]];
+        readonly name: string;
+        readonly bundleDependencies?: readonly string[];
+        readonly bundlePeerDependencies?: readonly string[];
+        readonly versioning?: ({
+            readonly automatic: true;
+            readonly minimumVersion?: string;
+        } & {
+            readonly _?: never;
+        }) | ({
+            readonly version: string;
+            readonly automatic: false;
+        } & {
+            readonly _?: never;
+        });
+    }[]];
+}>;
+export type PacktoryConfig = NoExpand<Schema.To<typeof packtoryConfigSchema>>;
+export type PackageConfig = PacktoryConfig['packages'][number];
+//# sourceMappingURL=config.d.ts.map

package/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../source/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EASH,KAAK,MAAM,EAGd,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,QAAQ,EAAwB,MAAM,uBAAuB,CAAC;AAsD5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;AAC9E,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/config/config.js

@@ -0,0 +1,65 @@
+import { boolean, union, optional, struct, array, tuple, nonEmptyArray, rest, partial, extend } from '@effect/schema/Schema';
+import { registrySettingsSchema } from './registry-settings.js';
+import { nonEmptyStringSchema } from './base-validations.js';
+import { versioningSettingsSchema } from './versioning-settings.js';
+import { additionalPackageJsonAttributesSchema, mainPackageJsonSchema } from './package-json.js';
+import { entryPointSchema } from './entry-point.js';
+import { additionalFileDescriptionSchema } from './additional-files.js';
+const $perPackageSettingsSchema = struct({
+    name: nonEmptyStringSchema,
+    entryPoints: tuple(entryPointSchema).pipe(rest(entryPointSchema)),
+    versioning: optional(versioningSettingsSchema, { exact: true }),
+    bundleDependencies: optional(array(nonEmptyStringSchema), { exact: true }),
+    bundlePeerDependencies: optional(array(nonEmptyStringSchema), { exact: true })
+});
+const perPackageSettingsSchema = $perPackageSettingsSchema;
+const optionalCommonPackageSettingsSchema = struct({
+    sourcesFolder: optional(nonEmptyStringSchema, { exact: true }),
+    mainPackageJson: optional(mainPackageJsonSchema, { exact: true })
+});
+const requiredCommonPackageSettingsSchema = struct({
+    sourcesFolder: nonEmptyStringSchema,
+    mainPackageJson: mainPackageJsonSchema
+});
+const commonPackageSettingsSourcesFolderRequiredSchema = struct({
+    sourcesFolder: nonEmptyStringSchema,
+    mainPackageJson: optional(mainPackageJsonSchema, { exact: true })
+});
+const commonPackageSettingsMainPackageJsonRequiredSchema = struct({
+    sourcesFolder: optional(nonEmptyStringSchema, { exact: true }),
+    mainPackageJson: mainPackageJsonSchema
+});
+const optionalPackageSettingsSchema = struct({
+    additionalFiles: optional(array(additionalFileDescriptionSchema), { exact: true }),
+    includeSourceMapFiles: optional(boolean, { exact: true }),
+    additionalPackageJsonAttributes: optional(additionalPackageJsonAttributesSchema, { exact: true })
+});
+const configWithOptionalCommonSettingsSchema = struct({
+    registrySettings: registrySettingsSchema,
+    commonPackageSettings: optional(optionalCommonPackageSettingsSchema.pipe(extend(optionalPackageSettingsSchema)), {
+        exact: true
+    }),
+    packages: nonEmptyArray(requiredCommonPackageSettingsSchema
+        .pipe(extend(optionalPackageSettingsSchema))
+        .pipe(extend(perPackageSettingsSchema)))
+});
+export const packtoryConfigSchema = union(configWithOptionalCommonSettingsSchema, struct({
+    registrySettings: registrySettingsSchema,
+    commonPackageSettings: requiredCommonPackageSettingsSchema.pipe(extend(optionalPackageSettingsSchema)),
+    packages: nonEmptyArray(partial(requiredCommonPackageSettingsSchema)
+        .pipe(extend(optionalPackageSettingsSchema))
+        .pipe(extend(perPackageSettingsSchema)))
+}), struct({
+    registrySettings: registrySettingsSchema,
+    commonPackageSettings: commonPackageSettingsMainPackageJsonRequiredSchema.pipe(extend(optionalPackageSettingsSchema)),
+    packages: nonEmptyArray(commonPackageSettingsSourcesFolderRequiredSchema
+        .pipe(extend(optionalPackageSettingsSchema))
+        .pipe(extend(perPackageSettingsSchema)))
+}), struct({
+    registrySettings: registrySettingsSchema,
+    commonPackageSettings: commonPackageSettingsSourcesFolderRequiredSchema.pipe(extend(optionalPackageSettingsSchema)),
+    packages: nonEmptyArray(commonPackageSettingsMainPackageJsonRequiredSchema
+        .pipe(extend(optionalPackageSettingsSchema))
+        .pipe(extend(perPackageSettingsSchema)))
+}));
+//# sourceMappingURL=config.js.map

package/config/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../source/config/config.ts"],"names":[],"mappings":"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"}

package/config/entry-point.d.ts

@@ -0,0 +1,13 @@
+import { type Schema } from '@effect/schema/Schema';
+import { type NoExpand } from './base-validations.js';
+declare const $entryPointSchema: Schema<{
+    readonly js: string;
+    readonly declarationFile?: string;
+}, {
+    readonly js: string;
+    readonly declarationFile?: string;
+}>;
+export type EntryPoint = NoExpand<Schema.To<typeof $entryPointSchema>>;
+export declare const entryPointSchema: Schema<EntryPoint>;
+export {};
+//# sourceMappingURL=entry-point.d.ts.map

package/config/entry-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.d.ts","sourceRoot":"","sources":["../../../../source/config/entry-point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAoB,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAwB,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAE5E,QAAA,MAAM,iBAAiB;;;;;;EAGrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC;AACvE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,UAAU,CAAqB,CAAC"}

package/config/entry-point.js

@@ -0,0 +1,8 @@
+import { struct, optional } from '@effect/schema/Schema';
+import { nonEmptyStringSchema } from './base-validations.js';
+const $entryPointSchema = struct({
+    js: nonEmptyStringSchema,
+    declarationFile: optional(nonEmptyStringSchema, { exact: true })
+});
+export const entryPointSchema = $entryPointSchema;
+//# sourceMappingURL=entry-point.js.map

package/config/entry-point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.js","sourceRoot":"","sources":["../../../../source/config/entry-point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAiB,MAAM,uBAAuB,CAAC;AAE5E,MAAM,iBAAiB,GAAG,MAAM,CAAC;IAC7B,EAAE,EAAE,oBAAoB;IACxB,eAAe,EAAE,QAAQ,CAAC,oBAAoB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;CACnE,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAuB,iBAAiB,CAAC"}

package/config/package-json.d.ts

@@ -0,0 +1,33 @@
+import { type Schema } from '@effect/schema/Schema';
+import type { JsonValue } from 'type-fest';
+import type { NoExpand } from './base-validations.js';
+declare const $mainPackageJsonSchema: Schema<{
+    readonly [x: string]: unknown;
+    readonly type?: "module";
+    readonly dependencies?: {
+        readonly [x: string]: string;
+    };
+    readonly devDependencies?: {
+        readonly [x: string]: string;
+    };
+}, {
+    readonly [x: string]: unknown;
+    readonly type?: "module";
+    readonly dependencies?: {
+        readonly [x: string]: string;
+    };
+    readonly devDependencies?: {
+        readonly [x: string]: string;
+    };
+}>;
+export type MainPackageJson = NoExpand<Schema.To<typeof $mainPackageJsonSchema>>;
+export declare const mainPackageJsonSchema: Schema<MainPackageJson>;
+declare const $additionalPackageJsonAttributesSchema: Schema<{
+    readonly [x: string]: JsonValue;
+}, {
+    readonly [x: string]: JsonValue;
+}>;
+export type AdditionalPackageJsonAttributes = Schema.To<typeof $additionalPackageJsonAttributesSchema>;
+export declare const additionalPackageJsonAttributesSchema: Schema<AdditionalPackageJsonAttributes>;
+export {};
+//# sourceMappingURL=package-json.d.ts.map

package/config/package-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json.d.ts","sourceRoot":"","sources":["../../../../source/config/package-json.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,MAAM,EAed,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKtD,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAIY,CAAC;AACzC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC;AACjF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,eAAe,CAA0B,CAAC;AA8CrF,QAAA,MAAM,sCAAsC;;;;EAAyE,CAAC;AACtH,MAAM,MAAM,+BAA+B,GAAG,MAAM,CAAC,EAAE,CAAC,OAAO,sCAAsC,CAAC,CAAC;AACvG,eAAO,MAAM,qCAAqC,EAAE,MAAM,CAAC,+BAA+B,CAChD,CAAC"}

package/config/package-json.js

@@ -0,0 +1,34 @@
+import { filter, struct, number, boolean, array, optional, literal, string, record, unknown, union, null as null_, extend, suspend } from '@effect/schema/Schema';
+const stringRecordSchema = record(string, string);
+const optionalStringRecordSchema = optional(stringRecordSchema, { exact: true });
+const $mainPackageJsonSchema = struct({
+    type: optional(literal('module'), { exact: true }),
+    dependencies: optionalStringRecordSchema,
+    devDependencies: optionalStringRecordSchema
+}).pipe(extend(record(string, unknown)));
+export const mainPackageJsonSchema = $mainPackageJsonSchema;
+const attributeValueSchema = union(string, number, boolean, null_, array(suspend(() => {
+    return attributeValueSchema;
+})), record(string, suspend(() => {
+    return attributeValueSchema;
+})));
+const forbiddenAttributeNames = new Set([
+    'dependencies',
+    'peerDependencies',
+    'main',
+    'name',
+    'types',
+    'type',
+    'version'
+]);
+const $additionalPackageJsonAttributeNameSchema = string.pipe(filter((value) => {
+    return !forbiddenAttributeNames.has(value);
+}, {
+    message(value) {
+        return `the key '${value}' is not allowed`;
+    }
+}));
+const additionalPackageJsonAttributeNameSchema = $additionalPackageJsonAttributeNameSchema;
+const $additionalPackageJsonAttributesSchema = record(additionalPackageJsonAttributeNameSchema, attributeValueSchema);
+export const additionalPackageJsonAttributesSchema = $additionalPackageJsonAttributesSchema;
+//# sourceMappingURL=package-json.js.map

package/config/package-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json.js","sourceRoot":"","sources":["../../../../source/config/package-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,KAAK,EACL,QAAQ,EACR,OAAO,EACP,MAAM,EACN,MAAM,EACN,OAAO,EACP,KAAK,EACL,IAAI,IAAI,KAAK,EACb,MAAM,EACN,OAAO,EACV,MAAM,uBAAuB,CAAC;AAI/B,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAClD,MAAM,0BAA0B,GAAG,QAAQ,CAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAEjF,MAAM,sBAAsB,GAAG,MAAM,CAAC;IAClC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAClD,YAAY,EAAE,0BAA0B;IACxC,eAAe,EAAE,0BAA0B;CAC9C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AAEzC,MAAM,CAAC,MAAM,qBAAqB,GAA4B,sBAAsB,CAAC;AAErF,MAAM,oBAAoB,GAAsB,KAAK,CACjD,MAAM,EACN,MAAM,EACN,OAAO,EACP,KAAK,EACL,KAAK,CACD,OAAO,CAAC,GAAG,EAAE;IACT,OAAO,oBAAoB,CAAC;AAChC,CAAC,CAAC,CACL,EACD,MAAM,CACF,MAAM,EACN,OAAO,CAAC,GAAG,EAAE;IACT,OAAO,oBAAoB,CAAC;AAChC,CAAC,CAAC,CACL,CACJ,CAAC;AAEF,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC;IACpC,cAAc;IACd,kBAAkB;IAClB,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,SAAS;CACZ,CAAC,CAAC;AAEH,MAAM,yCAAyC,GAAG,MAAM,CAAC,IAAI,CACzD,MAAM,CACF,CAAC,KAAK,EAAE,EAAE;IACN,OAAO,CAAC,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC,EACD;IACI,OAAO,CAAC,KAAK;QACT,OAAO,YAAY,KAAK,kBAAkB,CAAC;IAC/C,CAAC;CACJ,CACJ,CACJ,CAAC;AAEF,MAAM,wCAAwC,GAC1C,yCAAyC,CAAC;AAE9C,MAAM,sCAAsC,GAAG,MAAM,CAAC,wCAAwC,EAAE,oBAAoB,CAAC,CAAC;AAEtH,MAAM,CAAC,MAAM,qCAAqC,GAC9C,sCAAsC,CAAC"}