bleam 0.0.10 → 0.0.12

package/templates/updates/src/schema.ts

@@ -1,4 +1,4 @@
-export type ArtifactFormat = 'bleam-ota-zip-v1' | 'bleam-macos-app-zip-v1'
+export type ArtifactFormat = 'bleam-ota-zip-v1'
 
 export interface StoredArtifact {
   format: ArtifactFormat
@@ -11,43 +11,24 @@ export interface ResolvedArtifact extends StoredArtifact {
   url: string
 }
 
-interface ReleaseFields {
+export interface OtaRelease {
   schemaVersion: 1
+  kind: 'ota'
   bundleIdentifier: string
   teamIdentifier: string
   channel: 'stable'
   releaseId: string
-  publishedAt: string
-}
-
-export interface OtaRelease extends ReleaseFields {
-  kind: 'ota'
   bundleVersion: string
   runtimeVersion: string
   artifact: StoredArtifact & { format: 'bleam-ota-zip-v1' }
+  publishedAt: string
 }
 
-export interface PlatformRelease extends ReleaseFields {
-  kind: 'platform'
-  appVersion: string
-  buildNumber: string
-  bleamPlatformVersion: string
-  platformFingerprint?: string
-  redeploy: boolean
-  target: {
-    os: 'macos'
-    architecture: 'arm64'
-    installLocation: 'user-applications'
-    minimumMacOSVersion: string
-  }
-  artifact: StoredArtifact & { format: 'bleam-macos-app-zip-v1' }
-}
-
-export type StoredRelease = OtaRelease | PlatformRelease
+export type StoredRelease = OtaRelease
 
-export type ResolvedRelease =
-  | (Omit<OtaRelease, 'artifact'> & { artifact: ResolvedArtifact })
-  | (Omit<PlatformRelease, 'artifact'> & { artifact: ResolvedArtifact })
+export type ResolvedRelease = Omit<OtaRelease, 'artifact'> & {
+  artifact: ResolvedArtifact
+}
 
 export interface DownloadRecord {
   schemaVersion: 1
@@ -104,23 +85,6 @@ function version(value: unknown, field: string): string {
   return result
 }
 
-function numericString(value: unknown, field: string): string {
-  const result = string(value, field)
-  if (!/^\d+$/.test(result)) {
-    return invalid(field, 'must contain only decimal digits')
-  }
-  return result
-}
-
-function optionalSha256(value: unknown, field: string): string | undefined {
-  if (value === undefined) return undefined
-  const result = string(value, field)
-  if (!/^[a-f0-9]{64}$/.test(result)) {
-    return invalid(field, 'must be a lowercase SHA-256 hex digest')
-  }
-  return result
-}
-
 function publishedAt(value: unknown): string {
   const result = string(value, 'publishedAt')
   if (
@@ -140,44 +104,6 @@ export function isRuntimeVersion(value: string): boolean {
   return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value)
 }
 
-export function compareRuntimeVersions(left: string, right: string) {
-  const parse = (value: string) => {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(value)
-    if (!match) return invalid('runtimeVersion', 'must be a semantic version')
-    return {
-      core: match.slice(1, 4).map(Number),
-      prerelease: match[4]?.split('.'),
-    }
-  }
-  const a = parse(left)
-  const b = parse(right)
-  for (let index = 0; index < a.core.length; index += 1) {
-    if (a.core[index] !== b.core[index]) {
-      return (a.core[index] ?? 0) < (b.core[index] ?? 0) ? -1 : 1
-    }
-  }
-  if (!a.prerelease && !b.prerelease) return 0
-  if (!a.prerelease) return 1
-  if (!b.prerelease) return -1
-  const length = Math.max(a.prerelease.length, b.prerelease.length)
-  for (let index = 0; index < length; index += 1) {
-    const aPart = a.prerelease[index]
-    const bPart = b.prerelease[index]
-    if (aPart === undefined) return -1
-    if (bPart === undefined) return 1
-    if (aPart === bPart) continue
-    const aNumber = /^\d+$/.test(aPart) ? Number(aPart) : undefined
-    const bNumber = /^\d+$/.test(bPart) ? Number(bPart) : undefined
-    if (aNumber !== undefined && bNumber !== undefined) {
-      return aNumber < bNumber ? -1 : 1
-    }
-    if (aNumber !== undefined) return -1
-    if (bNumber !== undefined) return 1
-    return aPart < bPart ? -1 : 1
-  }
-  return 0
-}
-
 export function isDownloadId(value: string): boolean {
   return /^[a-z][a-z0-9_-]{2,127}$/.test(value)
 }
@@ -209,11 +135,9 @@ function teamIdentifier(value: unknown): string {
   return result
 }
 
-function artifact(value: unknown, kind: StoredRelease['kind']): StoredArtifact {
+function artifact(value: unknown): StoredArtifact {
   const input = record(value, 'artifact')
-  const expectedFormat =
-    kind === 'ota' ? 'bleam-ota-zip-v1' : 'bleam-macos-app-zip-v1'
-  exactString(input.format, 'artifact.format', expectedFormat)
+  exactString(input.format, 'artifact.format', 'bleam-ota-zip-v1')
 
   const downloadId = string(input.downloadId, 'artifact.downloadId')
   if (!isDownloadId(downloadId)) {
@@ -229,113 +153,34 @@ function artifact(value: unknown, kind: StoredRelease['kind']): StoredArtifact {
   }
 
   return {
-    format: expectedFormat,
+    format: 'bleam-ota-zip-v1',
     downloadId,
     sizeBytes: positiveInteger(input.sizeBytes, 'artifact.sizeBytes'),
     sha256,
   }
 }
 
-function releaseFields(input: Record<string, unknown>): ReleaseFields {
+export function parseStoredRelease(value: unknown): StoredRelease {
+  const input = record(value, 'manifest')
   if (input.schemaVersion !== 1) {
     return invalid('schemaVersion', 'must be 1')
   }
-
+  exactString(input.kind, 'kind', 'ota')
   exactString(input.channel, 'channel', 'stable')
   return {
     schemaVersion: 1,
+    kind: 'ota',
     bundleIdentifier: bundleIdentifier(input.bundleIdentifier),
     teamIdentifier: teamIdentifier(input.teamIdentifier),
     channel: 'stable',
     releaseId: releaseId(input.releaseId),
+    bundleVersion: string(input.bundleVersion, 'bundleVersion'),
+    runtimeVersion: version(input.runtimeVersion, 'runtimeVersion'),
+    artifact: artifact(input.artifact),
     publishedAt: publishedAt(input.publishedAt),
   }
 }
 
-export function parseStoredRelease(value: unknown): StoredRelease {
-  const input = record(value, 'manifest')
-  const kind = string(input.kind, 'kind')
-  const fields = releaseFields(input)
-
-  if (kind === 'ota') {
-    const parsedArtifact = artifact(input.artifact, kind)
-    return {
-      ...fields,
-      kind,
-      bundleVersion: string(input.bundleVersion, 'bundleVersion'),
-      runtimeVersion: version(input.runtimeVersion, 'runtimeVersion'),
-      artifact: {
-        ...parsedArtifact,
-        format: 'bleam-ota-zip-v1',
-      },
-    }
-  }
-
-  if (kind === 'platform') {
-    const target = record(input.target, 'target')
-    exactString(target.os, 'target.os', 'macos')
-    exactString(target.architecture, 'target.architecture', 'arm64')
-    exactString(
-      target.installLocation,
-      'target.installLocation',
-      'user-applications',
-    )
-    const minimumMacOSVersion = string(
-      target.minimumMacOSVersion,
-      'target.minimumMacOSVersion',
-    )
-    if (!/^\d+(?:\.\d+){0,2}$/.test(minimumMacOSVersion)) {
-      return invalid(
-        'target.minimumMacOSVersion',
-        'must be a macOS version number',
-      )
-    }
-
-    const parsedArtifact = artifact(input.artifact, kind)
-    return {
-      ...fields,
-      kind,
-      appVersion: version(input.appVersion, 'appVersion'),
-      buildNumber: numericString(input.buildNumber, 'buildNumber'),
-      bleamPlatformVersion: version(
-        input.bleamPlatformVersion,
-        'bleamPlatformVersion',
-      ),
-      platformFingerprint: optionalSha256(
-        input.platformFingerprint,
-        'platformFingerprint',
-      ),
-      redeploy: input.redeploy === true,
-      target: {
-        os: 'macos',
-        architecture: 'arm64',
-        installLocation: 'user-applications',
-        minimumMacOSVersion,
-      },
-      artifact: {
-        ...parsedArtifact,
-        format: 'bleam-macos-app-zip-v1',
-      },
-    }
-  }
-
-  return invalid('kind', 'must be "ota" or "platform"')
-}
-
-export function parsePublishedRelease(value: unknown): StoredRelease {
-  const release = parseStoredRelease(value)
-  if (release.kind !== 'platform') return release
-
-  const input = record(value, 'manifest')
-  if (release.platformFingerprint === undefined) {
-    return invalid('platformFingerprint', 'is required')
-  }
-  if (typeof input.redeploy !== 'boolean') {
-    return invalid('redeploy', 'must be a boolean')
-  }
-  return release
-}
-
 export function parseDownloadRecord(value: unknown): DownloadRecord {
   const input = record(value, 'download record')
   if (input.schemaVersion !== 1) {

package/dist/schema-Bo5Jvqus.js

@@ -1,90 +0,0 @@
-//#region src/schema.ts
-var SchemaError = class extends Error {
-	constructor(issues) {
-		super(issues.map((issue) => issue.message).join("\n"));
-		this.issues = issues;
-		this.name = "SchemaError";
-	}
-};
-function tokenMatches(token, value) {
-	return typeof value === token;
-}
-function issueFor(key, expected) {
-	return {
-		message: `Expected ${key} to be ${expected}`,
-		path: [key]
-	};
-}
-function parseShape(shape, value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return { issues: [{ message: "Expected object" }] };
-	const input = value;
-	const output = {};
-	const issues = [];
-	for (const [key, field] of Object.entries(shape)) {
-		const inputValue = input[key];
-		if (typeof field === "function") {
-			const defaultValue = field();
-			const expected = typeof defaultValue;
-			if (inputValue === void 0) {
-				output[key] = defaultValue;
-				continue;
-			}
-			if (tokenMatches(expected, inputValue)) {
-				output[key] = inputValue;
-				continue;
-			}
-			issues.push(issueFor(key, expected));
-			continue;
-		}
-		if (inputValue === void 0) continue;
-		if (tokenMatches(field, inputValue)) {
-			output[key] = inputValue;
-			continue;
-		}
-		issues.push(issueFor(key, field));
-	}
-	if (issues.length > 0) return { issues };
-	return { value: output };
-}
-function createSchema(validate, jsonSchema) {
-	return {
-		"~standard": {
-			version: 1,
-			vendor: "bleam",
-			validate
-		},
-		parse(value) {
-			const result = validate(value);
-			if (result.issues !== void 0) throw new SchemaError(result.issues);
-			return result.value;
-		},
-		safeParse: validate,
-		toJSONSchema: jsonSchema,
-		transform(transform) {
-			return createSchema((value) => {
-				const result = validate(value);
-				if (result.issues !== void 0) return result;
-				return { value: transform(result.value) };
-			}, jsonSchema);
-		}
-	};
-}
-function schema(shape) {
-	return createSchema((value) => parseShape(shape, value), () => {
-		const properties = {};
-		const required = [];
-		for (const [key, field] of Object.entries(shape)) {
-			if (typeof field === "function") properties[key] = { type: typeof field() };
-			else properties[key] = { type: field };
-			required.push(key);
-		}
-		return {
-			type: "object",
-			properties,
-			required
-		};
-	});
-}
-
-//#endregion
-export { schema as n, SchemaError as t };

package/dist/schema-DOOjfXvs.d.ts

@@ -1,58 +0,0 @@
-//#region src/schema.d.ts
-type FieldValue = string | number | boolean;
-type FieldToken = 'string' | 'number' | 'boolean';
-type FieldDefault<T extends FieldValue = FieldValue> = () => T;
-type FieldSchema = FieldToken | FieldDefault;
-type SchemaShape = Record<string, FieldSchema>;
-interface SchemaIssue {
-  message: string;
-  path?: ReadonlyArray<PropertyKey | {
-    key: PropertyKey;
-  }>;
-}
-type SchemaResult<Output> = {
-  value: Output;
-  issues?: undefined;
-} | {
-  issues: ReadonlyArray<SchemaIssue>;
-};
-interface StandardSchema<Input = unknown, Output = Input> {
-  readonly '~standard': {
-    readonly version: 1;
-    readonly vendor: string;
-    readonly validate: (value: unknown) => SchemaResult<Output>;
-    readonly types?: {
-      readonly input: Input;
-      readonly output: Output;
-    };
-  };
-}
-type TokenValue<T extends FieldToken> = T extends 'string' ? string : T extends 'number' ? number : boolean;
-type DefaultValue<T> = T extends (() => infer Value) ? Value extends FieldValue ? Value : never : never;
-type TokenKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldToken ? Key : never }[keyof Shape];
-type DefaultKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldDefault ? Key : never }[keyof Shape];
-type FieldInput<Field extends FieldSchema> = Field extends FieldToken ? TokenValue<Field> : Field extends FieldDefault ? DefaultValue<Field> : never;
-type SchemaInput<Shape extends SchemaShape> = { [Key in keyof Shape]?: FieldInput<Shape[Key]> };
-type SchemaOutput<Shape extends SchemaShape> = { [Key in TokenKeys<Shape>]?: Shape[Key] extends FieldToken ? TokenValue<Shape[Key]> : never } & { [Key in DefaultKeys<Shape>]: Shape[Key] extends FieldDefault ? DefaultValue<Shape[Key]> : never };
-type InferInput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['input'];
-type InferOutput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['output'];
-declare class SchemaError extends Error {
-  readonly issues: ReadonlyArray<SchemaIssue>;
-  constructor(issues: ReadonlyArray<SchemaIssue>);
-}
-interface BleamSchema<Input, Output> extends StandardSchema<Input, Output> {
-  parse(value: unknown): Output;
-  safeParse(value: unknown): SchemaResult<Output>;
-  toJSONSchema(): SchemaJSONSchema;
-  transform<NextOutput>(transform: (value: Output) => NextOutput): BleamSchema<Input, NextOutput>;
-}
-type SchemaJSONSchema = {
-  type: 'object';
-  properties: Record<string, {
-    type: FieldToken;
-  }>;
-  required: string[];
-};
-declare function schema<Shape extends SchemaShape>(shape: Shape): BleamSchema<SchemaInput<Shape>, SchemaOutput<Shape>>;
-//#endregion
-export { FieldValue as a, SchemaError as c, SchemaJSONSchema as d, SchemaOutput as f, schema as g, StandardSchema as h, FieldToken as i, SchemaInput as l, SchemaShape as m, FieldDefault as n, InferInput as o, SchemaResult as p, FieldSchema as r, InferOutput as s, BleamSchema as t, SchemaIssue as u };

package/dist/schema-ENSMX_1t.d.cts

@@ -1,58 +0,0 @@
-//#region src/schema.d.ts
-type FieldValue = string | number | boolean;
-type FieldToken = 'string' | 'number' | 'boolean';
-type FieldDefault<T extends FieldValue = FieldValue> = () => T;
-type FieldSchema = FieldToken | FieldDefault;
-type SchemaShape = Record<string, FieldSchema>;
-interface SchemaIssue {
-  message: string;
-  path?: ReadonlyArray<PropertyKey | {
-    key: PropertyKey;
-  }>;
-}
-type SchemaResult<Output> = {
-  value: Output;
-  issues?: undefined;
-} | {
-  issues: ReadonlyArray<SchemaIssue>;
-};
-interface StandardSchema<Input = unknown, Output = Input> {
-  readonly '~standard': {
-    readonly version: 1;
-    readonly vendor: string;
-    readonly validate: (value: unknown) => SchemaResult<Output>;
-    readonly types?: {
-      readonly input: Input;
-      readonly output: Output;
-    };
-  };
-}
-type TokenValue<T extends FieldToken> = T extends 'string' ? string : T extends 'number' ? number : boolean;
-type DefaultValue<T> = T extends (() => infer Value) ? Value extends FieldValue ? Value : never : never;
-type TokenKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldToken ? Key : never }[keyof Shape];
-type DefaultKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldDefault ? Key : never }[keyof Shape];
-type FieldInput<Field extends FieldSchema> = Field extends FieldToken ? TokenValue<Field> : Field extends FieldDefault ? DefaultValue<Field> : never;
-type SchemaInput<Shape extends SchemaShape> = { [Key in keyof Shape]?: FieldInput<Shape[Key]> };
-type SchemaOutput<Shape extends SchemaShape> = { [Key in TokenKeys<Shape>]?: Shape[Key] extends FieldToken ? TokenValue<Shape[Key]> : never } & { [Key in DefaultKeys<Shape>]: Shape[Key] extends FieldDefault ? DefaultValue<Shape[Key]> : never };
-type InferInput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['input'];
-type InferOutput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['output'];
-declare class SchemaError extends Error {
-  readonly issues: ReadonlyArray<SchemaIssue>;
-  constructor(issues: ReadonlyArray<SchemaIssue>);
-}
-interface BleamSchema<Input, Output> extends StandardSchema<Input, Output> {
-  parse(value: unknown): Output;
-  safeParse(value: unknown): SchemaResult<Output>;
-  toJSONSchema(): SchemaJSONSchema;
-  transform<NextOutput>(transform: (value: Output) => NextOutput): BleamSchema<Input, NextOutput>;
-}
-type SchemaJSONSchema = {
-  type: 'object';
-  properties: Record<string, {
-    type: FieldToken;
-  }>;
-  required: string[];
-};
-declare function schema<Shape extends SchemaShape>(shape: Shape): BleamSchema<SchemaInput<Shape>, SchemaOutput<Shape>>;
-//#endregion
-export { FieldValue as a, SchemaError as c, SchemaJSONSchema as d, SchemaOutput as f, schema as g, StandardSchema as h, FieldToken as i, SchemaInput as l, SchemaShape as m, FieldDefault as n, InferInput as o, SchemaResult as p, FieldSchema as r, InferOutput as s, BleamSchema as t, SchemaIssue as u };

package/dist/schema-rQ13mrpD.cjs

@@ -1,102 +0,0 @@
-
-//#region src/schema.ts
-var SchemaError = class extends Error {
-	constructor(issues) {
-		super(issues.map((issue) => issue.message).join("\n"));
-		this.issues = issues;
-		this.name = "SchemaError";
-	}
-};
-function tokenMatches(token, value) {
-	return typeof value === token;
-}
-function issueFor(key, expected) {
-	return {
-		message: `Expected ${key} to be ${expected}`,
-		path: [key]
-	};
-}
-function parseShape(shape, value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return { issues: [{ message: "Expected object" }] };
-	const input = value;
-	const output = {};
-	const issues = [];
-	for (const [key, field] of Object.entries(shape)) {
-		const inputValue = input[key];
-		if (typeof field === "function") {
-			const defaultValue = field();
-			const expected = typeof defaultValue;
-			if (inputValue === void 0) {
-				output[key] = defaultValue;
-				continue;
-			}
-			if (tokenMatches(expected, inputValue)) {
-				output[key] = inputValue;
-				continue;
-			}
-			issues.push(issueFor(key, expected));
-			continue;
-		}
-		if (inputValue === void 0) continue;
-		if (tokenMatches(field, inputValue)) {
-			output[key] = inputValue;
-			continue;
-		}
-		issues.push(issueFor(key, field));
-	}
-	if (issues.length > 0) return { issues };
-	return { value: output };
-}
-function createSchema(validate, jsonSchema) {
-	return {
-		"~standard": {
-			version: 1,
-			vendor: "bleam",
-			validate
-		},
-		parse(value) {
-			const result = validate(value);
-			if (result.issues !== void 0) throw new SchemaError(result.issues);
-			return result.value;
-		},
-		safeParse: validate,
-		toJSONSchema: jsonSchema,
-		transform(transform) {
-			return createSchema((value) => {
-				const result = validate(value);
-				if (result.issues !== void 0) return result;
-				return { value: transform(result.value) };
-			}, jsonSchema);
-		}
-	};
-}
-function schema(shape) {
-	return createSchema((value) => parseShape(shape, value), () => {
-		const properties = {};
-		const required = [];
-		for (const [key, field] of Object.entries(shape)) {
-			if (typeof field === "function") properties[key] = { type: typeof field() };
-			else properties[key] = { type: field };
-			required.push(key);
-		}
-		return {
-			type: "object",
-			properties,
-			required
-		};
-	});
-}
-
-//#endregion
-Object.defineProperty(exports, 'SchemaError', {
-  enumerable: true,
-  get: function () {
-    return SchemaError;
-  }
-});
-Object.defineProperty(exports, 'schema', {
-  enumerable: true,
-  get: function () {
-    return schema;
-  }
-});