@slicemachine/manager 0.1.1-dev-plugins.13 → 0.1.1-dev-plugins-validation.1

package/src/managers/project/ProjectManager.ts

@@ -2,18 +2,24 @@ import * as fs from "node:fs/promises";
 import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { createRequire } from "node:module";
+import { detect as niDetect } from "@antfu/ni";
+import { ExecaChildProcess } from "execa";
 
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
 import { decodeSliceMachineConfig } from "../../lib/decodeSliceMachineConfig";
+import { format } from "../../lib/format";
+import { installDependencies } from "../../lib/installDependencies";
 import { locateFileUpward } from "../../lib/locateFileUpward";
 
-import { SliceMachineConfig } from "../../types";
+import { PackageManager, SliceMachineConfig } from "../../types";
+
+import { SliceMachineError, InternalError } from "../../errors";
 
 import { SLICE_MACHINE_CONFIG_FILENAME } from "../../constants/SLICE_MACHINE_CONFIG_FILENAME";
 import { TS_CONFIG_FILENAME } from "../../constants/TS_CONFIG_FILENAME";
 import { SLICE_MACHINE_NPM_PACKAGE_NAME } from "../../constants/SLICE_MACHINE_NPM_PACKAGE_NAME";
 
 import { BaseManager } from "../BaseManager";
-import { format } from "../../lib/format";
 
 type ProjectManagerGetSliceMachineConfigPathArgs = {
 	ignoreCache?: boolean;
@@ -32,6 +38,25 @@ type ProjectManagerWriteSliceMachineConfigArgs = {
 	path?: string;
 };
 
+type ProjectManagerInitProjectArgs = {
+	log?: (message: string) => void;
+};
+
+type ProjectManagerDetectPackageManager = {
+	root?: string;
+};
+
+type ProjectManagerInstallDependenciesArgs = {
+	dependencies: Record<string, string>;
+	dev?: boolean;
+	packageManager?: PackageManager;
+	log?: (message: string) => void;
+};
+
+type ProjectManagerInstallDependenciesReturnType = {
+	execaProcess: ExecaChildProcess;
+};
+
 export class ProjectManager extends BaseManager {
 	private _cachedRoot: string | undefined;
 	private _cachedSliceMachineConfigPath: string | undefined;
@@ -162,4 +187,95 @@ export class ProjectManager extends BaseManager {
 
 		return path.dirname(sliceMachinePackageJSONPath);
 	}
+
+	async initProject(args?: ProjectManagerInitProjectArgs): Promise<void> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		// eslint-disable-next-line no-console
+		const log = args?.log || console.log.bind(this);
+
+		const { errors } = await this.sliceMachinePluginRunner.callHook(
+			"project:init",
+			{
+				log,
+				installDependencies: async (args) => {
+					const { execaProcess } = await this.installDependencies({
+						dependencies: args.dependencies,
+						dev: args.dev,
+						log,
+					});
+
+					await execaProcess;
+				},
+			},
+		);
+
+		if (errors.length > 0) {
+			// TODO: Provide better error message.
+			throw new SliceMachineError(
+				`Failed to initialize project: ${errors.join(", ")}`,
+			);
+		}
+	}
+
+	async detectPackageManager(
+		args?: ProjectManagerDetectPackageManager,
+	): Promise<PackageManager> {
+		const projectRoot = args?.root || (await this.getRoot());
+
+		const packageManager = await niDetect({
+			autoInstall: true,
+			cwd: projectRoot,
+		});
+
+		return packageManager || "npm";
+	}
+
+	async installDependencies(
+		args: ProjectManagerInstallDependenciesArgs,
+	): Promise<ProjectManagerInstallDependenciesReturnType> {
+		const packageManager =
+			args.packageManager || (await this.detectPackageManager());
+
+		// eslint-disable-next-line no-console
+		const log = args.log || console.log.bind(this);
+
+		const wrappedLogger = (data: Buffer | string | null) => {
+			if (data instanceof Buffer) {
+				log(data.toString());
+			} else if (typeof data === "string") {
+				log(data);
+			}
+		};
+
+		try {
+			const { execaProcess } = await installDependencies({
+				packageManager,
+				dependencies: args.dependencies,
+				dev: args.dev,
+			});
+
+			// Don't clutter console with logs when process is non TTY (CI, etc.)
+			if (process.stdout.isTTY || process.env.NODE_ENV === "test") {
+				execaProcess.stdout?.on("data", wrappedLogger);
+			}
+			execaProcess.stderr?.on("data", wrappedLogger);
+
+			return {
+				execaProcess,
+			};
+		} catch (error) {
+			if (
+				error instanceof Error &&
+				"shortMessage" in error &&
+				"stderr" in error
+			) {
+				throw new InternalError("Package installation failed", {
+					cause: error,
+				});
+			}
+
+			throw error;
+		}
+	}
 }

package/src/managers/slices/SlicesManager.ts

@@ -62,7 +62,7 @@ type SliceMachineManagerReadAllSlicesReturnType = {
 };
 
 type SliceMachineManagerReadSliceReturnType = {
-	model: CustomTypes.Widgets.Slices.SharedSlice;
+	model: CustomTypes.Widgets.Slices.SharedSlice | undefined;
 	errors: (DecodeError | HookError)[];
 };
 

package/src/managers/telemetry/TelemetryManager.ts

@@ -32,7 +32,6 @@ function assertTelemetryInitialized(
 }
 
 export class TelemetryManager extends BaseManager {
-	private _enabled = false;
 	private _segmentClient: SegmentClient | undefined = undefined;
 	private _anonymousID: string | undefined = undefined;
 	private _userID: string | undefined = undefined;
@@ -43,19 +42,11 @@ export class TelemetryManager extends BaseManager {
 			return;
 		}
 
-		let root: string;
-		try {
-			root = await this.project.getRoot();
-		} catch {
-			root = await this.project.suggestRoot();
-		}
-
-		this._enabled = readPrismicrc(root).telemetry !== false;
 		this._segmentClient = new SegmentClient(API_TOKENS.SegmentKey, {
 			// Since it's a local app, we do not benefit from event batching the way a server would normally do, all tracking event will be awaited.
 			flushAt: 1,
 			// TODO: Verify that this actually does not send data to Segment when false.
-			enable: this._enabled,
+			enable: await this.checkIsTelemetryEnabled(),
 			errorHandler: () => {
 				// noop - We don't care if the tracking event
 				// failed. Some users or networks intentionally
@@ -105,14 +96,20 @@ export class TelemetryManager extends BaseManager {
 			assertTelemetryInitialized(this._segmentClient);
 
 			// TODO: Make sure client fails gracefully when no internet connection
-			this._segmentClient.track(payload, (maybeError?: Error) => {
-				if (maybeError) {
-					// TODO: Not sure how we want to deal with that
-					console.warn(`An error occurred during Segment tracking`, maybeError);
-				}
-
-				resolve();
-			});
+			this._segmentClient.track(
+				payload as Parameters<typeof this._segmentClient.track>[0],
+				(maybeError?: Error) => {
+					if (maybeError) {
+						// TODO: Not sure how we want to deal with that
+						console.warn(
+							`An error occurred during Segment tracking`,
+							maybeError,
+						);
+					}
+
+					resolve();
+				},
+			);
 		});
 	}
 
@@ -145,4 +142,15 @@ export class TelemetryManager extends BaseManager {
 			});
 		});
 	}
+
+	async checkIsTelemetryEnabled(): Promise<boolean> {
+		let root: string;
+		try {
+			root = await this.project.getRoot();
+		} catch {
+			root = await this.project.suggestRoot();
+		}
+
+		return readPrismicrc(root).telemetry !== false;
+	}
 }

package/src/managers/telemetry/types.ts

@@ -1,17 +1,73 @@
+import type { LimitType } from "../prismicRepository/types";
+
 export const SegmentEventType = {
 	command_init_start: "command:init:start",
 	command_init_identify: "command:init:identify",
 	command_init_end: "command:init:end",
+	review: "review",
+	onboarding_start: "onboarding:start",
+	onboarding_skip: "onboarding:skip",
+	onboarding_continue_screenIntro: "onboarding:continue:screen-intro",
+	onboarding_continue_screen1: "onboarding:continue:screen-1",
+	onboarding_continue_screen2: "onboarding:continue:screen-2",
+	onboarding_continue_screen3: "onboarding:continue:screen-3",
+	sliceSimulator_setup: "slice-simulator:setup",
+	sliceSimulator_open: "slice-simulator:open",
+	sliceSimulator_isNotRunning: "slice-simulator:is-not-running",
+	pageView: "page-view",
+	openVideoTutorials: "open-video-tutorials",
+	customType_created: "custom-type:created",
+	customType_fieldAdded: "custom-type:field-added",
+	customType_sliceZoneUpdated: "custom-type:slice-zone-updated",
+	customType_saved: "custom-type:saved",
+	slice_created: "slice:created",
+	identifyUser: "identify-user",
+	groupLibraries: "group-libraries",
+	screenshotTaken: "screenshot-taken",
+	changes_pushed: "changes:pushed",
+	changes_limitReach: "changes:limit-reach",
+	editor_widgetUsed: "editor:widget-used",
 } as const;
-type SegmentEventTypes = typeof SegmentEventType[keyof typeof SegmentEventType];
+type SegmentEventTypes =
+	(typeof SegmentEventType)[keyof typeof SegmentEventType];
 
 export const HumanSegmentEventType = {
 	[SegmentEventType.command_init_start]: "SliceMachine Init Start",
 	[SegmentEventType.command_init_identify]: "SliceMachine Init Identify",
 	[SegmentEventType.command_init_end]: "SliceMachine Init End",
+	[SegmentEventType.review]: "SliceMachine Review",
+	[SegmentEventType.onboarding_start]: "SliceMachine Onboarding Start",
+	[SegmentEventType.onboarding_skip]: "SliceMachine Onboarding Skip",
+	[SegmentEventType.onboarding_continue_screenIntro]:
+		"SliceMachine Onboarding Continue Screen Intro",
+	[SegmentEventType.onboarding_continue_screen1]:
+		"SliceMachine Onboarding Continue Screen 1",
+	[SegmentEventType.onboarding_continue_screen2]:
+		"SliceMachine Onboarding Continue Screen 2",
+	[SegmentEventType.onboarding_continue_screen3]:
+		"SliceMachine Onboarding Continue Screen 3",
+	[SegmentEventType.sliceSimulator_setup]: "SliceMachine Slice Simulator Setup",
+	[SegmentEventType.sliceSimulator_open]: "SliceMachine Slice Simulator Open",
+	[SegmentEventType.sliceSimulator_isNotRunning]:
+		"SliceMachine Slice Simulator is not running",
+	[SegmentEventType.pageView]: "SliceMachine Page View",
+	[SegmentEventType.openVideoTutorials]: "SliceMachine Open Video Tutorials",
+	[SegmentEventType.customType_created]: "SliceMachine Custom Type Created",
+	[SegmentEventType.customType_fieldAdded]:
+		"SliceMachine Custom Type Field Added",
+	[SegmentEventType.customType_sliceZoneUpdated]:
+		"SliceMachine Slicezone Updated",
+	[SegmentEventType.customType_saved]: "SliceMachine Custom Type Saved",
+	[SegmentEventType.slice_created]: "SliceMachine Slice Created",
+	[SegmentEventType.identifyUser]: "IdentifyUser",
+	[SegmentEventType.groupLibraries]: "GroupLibraries",
+	[SegmentEventType.screenshotTaken]: "SliceMachine Screenshot Taken",
+	[SegmentEventType.changes_pushed]: "SliceMachine Changes Pushed",
+	[SegmentEventType.changes_limitReach]: "SliceMachine Changes Limit Reach",
+	[SegmentEventType.editor_widgetUsed]: "SliceMachine Editor Widget Used",
 } as const;
 export type HumanSegmentEventTypes =
-	typeof HumanSegmentEventType[keyof typeof HumanSegmentEventType];
+	(typeof HumanSegmentEventType)[keyof typeof HumanSegmentEventType];
 
 type SegmentEvent<
 	TType extends SegmentEventTypes,
@@ -40,7 +96,173 @@ type CommandInitEndSegmentEvent = SegmentEvent<
 	{ framework: string; success: boolean; error?: string }
 >;
 
+type ReviewSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.review,
+	{ framework: string; rating: number; comment: string }
+>;
+
+type OnboardingStartSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.onboarding_start
+>;
+
+type OnboardingSkipSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.onboarding_skip,
+	{ screenSkipped: number }
+>;
+
+type OnboardingContinueScreenIntroSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.onboarding_continue_screenIntro
+>;
+
+type OnboardingContinueScreen1SegmentEvent = SegmentEvent<
+	typeof SegmentEventType.onboarding_continue_screen1
+>;
+
+type OnboardingContinueScreen2SegmentEvent = SegmentEvent<
+	typeof SegmentEventType.onboarding_continue_screen2
+>;
+
+type OnboardingContinueScreen3SegmentEvent = SegmentEvent<
+	typeof SegmentEventType.onboarding_continue_screen3
+>;
+
+type SliceSimulatorSetupSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.sliceSimulator_setup,
+	{ framework: string; version: string }
+>;
+
+type SliceSimulatorOpenSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.sliceSimulator_open,
+	{ framework: string; version: string }
+>;
+
+type SliceSimulatorIsNotRunningSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.sliceSimulator_isNotRunning,
+	{ framework: string }
+>;
+
+type PageViewSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.pageView,
+	{
+		url: string;
+		path: string;
+		search: string;
+		title: string;
+		referrer: string;
+		framework: string;
+		slicemachineVersion: string;
+	}
+>;
+
+type OpenVideoTutorialsSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.openVideoTutorials,
+	{ framework: string; slicemachineVersion: string; video: string }
+>;
+
+type CustomTypeCreatedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.customType_created,
+	{ id: string; name: string; type: "repeatable" | "single" }
+>;
+
+type CustomTypeFieldAddedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.customType_fieldAdded,
+	{
+		id: string; // field id
+		name: string; // custom type id
+		zone: "static" | "repeatable";
+		type: string;
+	}
+>;
+
+type CustomTypeSliceZoneUpdatedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.customType_sliceZoneUpdated,
+	{ customTypeId: string }
+>;
+
+type CustomTypeSavedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.customType_saved,
+	{ id: string; name: string; type: "repeatable" | "single" }
+>;
+
+type SliceCreatedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.slice_created,
+	{ id: string; name: string; library: string }
+>;
+
+type IdentifyUserSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.identifyUser
+>;
+
+type GroupLibrariesSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.groupLibraries,
+	{
+		repoName: string;
+		manualLibsCount: number;
+		downloadedLibsCount: number;
+		npmLibsCount: number;
+		downloadedLibs: Array<string>;
+		slicemachineVersion: string;
+	}
+>;
+
+type ScreenshotTakenSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.screenshotTaken,
+	{
+		type: "custom" | "automatic";
+		method: "fromSimulator" | "upload" | "dragAndDrop";
+	}
+>;
+
+type ChangesPushedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.changes_pushed,
+	{
+		customTypesCreated: number;
+		customTypesModified: number;
+		customTypesDeleted: number;
+		slicesCreated: number;
+		slicesModified: number;
+		slicesDeleted: number;
+		missingScreenshots: number;
+		total: number;
+		duration: number;
+		hasDeletedDocuments: boolean;
+	}
+>;
+
+type ChangesLimitReachSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.changes_limitReach,
+	{ limitType: LimitType }
+>;
+
+type EditorWidgetUsedSegmentEvent = SegmentEvent<
+	typeof SegmentEventType.editor_widgetUsed,
+	{ sliceId: string }
+>;
+
 export type SegmentEvents =
 	| CommandInitStartSegmentEvent
 	| CommandInitIdentifySegmentEvent
-	| CommandInitEndSegmentEvent;
+	| CommandInitEndSegmentEvent
+	| ReviewSegmentEvent
+	| OnboardingStartSegmentEvent
+	| OnboardingSkipSegmentEvent
+	| OnboardingContinueScreenIntroSegmentEvent
+	| OnboardingContinueScreen1SegmentEvent
+	| OnboardingContinueScreen2SegmentEvent
+	| OnboardingContinueScreen3SegmentEvent
+	| SliceSimulatorSetupSegmentEvent
+	| SliceSimulatorOpenSegmentEvent
+	| SliceSimulatorIsNotRunningSegmentEvent
+	| PageViewSegmentEvent
+	| OpenVideoTutorialsSegmentEvent
+	| CustomTypeCreatedSegmentEvent
+	| CustomTypeFieldAddedSegmentEvent
+	| CustomTypeSliceZoneUpdatedSegmentEvent
+	| CustomTypeSavedSegmentEvent
+	| SliceCreatedSegmentEvent
+	| IdentifyUserSegmentEvent
+	| GroupLibrariesSegmentEvent
+	| ScreenshotTakenSegmentEvent
+	| ChangesPushedSegmentEvent
+	| ChangesLimitReachSegmentEvent
+	| EditorWidgetUsedSegmentEvent;

package/src/managers/versions/VersionsManager.ts

@@ -22,7 +22,7 @@ import { Version } from "./types";
 const detectVersionBumpKind = (
 	to: string,
 	from?: string,
-): typeof VERSION_KIND[keyof typeof VERSION_KIND] | undefined => {
+): (typeof VERSION_KIND)[keyof typeof VERSION_KIND] | undefined => {
 	if (!from) {
 		return VERSION_KIND.FIRST;
 	}

package/src/managers/versions/types.ts

@@ -2,5 +2,5 @@ import { VERSION_KIND } from "../../constants/VERSION_KIND";
 
 export type Version = {
 	version: string;
-	kind: typeof VERSION_KIND[keyof typeof VERSION_KIND] | undefined;
+	kind: (typeof VERSION_KIND)[keyof typeof VERSION_KIND] | undefined;
 };

package/src/types.ts

@@ -1,7 +1,9 @@
 import { HookError, SliceMachinePluginOptions } from "@slicemachine/plugin-kit";
+import { detect as niDetect } from "@antfu/ni";
+
 import { VERSION_KIND } from "./constants/VERSION_KIND";
 
-export type PackageManager = "npm" | "yarn";
+export type PackageManager = NonNullable<Awaited<ReturnType<typeof niDetect>>>;
 
 export type PackageChangelog = {
 	currentVersion: string;
@@ -13,7 +15,7 @@ export type PackageChangelog = {
 export type PackageVersion = {
 	versionNumber: string;
 	releaseNote: string | null;
-	kind: typeof VERSION_KIND[keyof typeof VERSION_KIND] | undefined;
+	kind: (typeof VERSION_KIND)[keyof typeof VERSION_KIND] | undefined;
 };
 
 /**

package/dist/__node_modules/@msgpack/msgpack/dist.es5_esm/CachedKeyDecoder.cjs

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const utf8 = require("./utils/utf8.cjs");
-var DEFAULT_MAX_KEY_LENGTH = 16;
-var DEFAULT_MAX_LENGTH_PER_KEY = 16;
-var CachedKeyDecoder = function() {
-  function CachedKeyDecoder2(maxKeyLength, maxLengthPerKey) {
-    if (maxKeyLength === void 0) {
-      maxKeyLength = DEFAULT_MAX_KEY_LENGTH;
-    }
-    if (maxLengthPerKey === void 0) {
-      maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY;
-    }
-    this.maxKeyLength = maxKeyLength;
-    this.maxLengthPerKey = maxLengthPerKey;
-    this.hit = 0;
-    this.miss = 0;
-    this.caches = [];
-    for (var i = 0; i < this.maxKeyLength; i++) {
-      this.caches.push([]);
-    }
-  }
-  CachedKeyDecoder2.prototype.canBeCached = function(byteLength) {
-    return byteLength > 0 && byteLength <= this.maxKeyLength;
-  };
-  CachedKeyDecoder2.prototype.find = function(bytes, inputOffset, byteLength) {
-    var records = this.caches[byteLength - 1];
-    FIND_CHUNK:
-      for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
-        var record = records_1[_i];
-        var recordBytes = record.bytes;
-        for (var j = 0; j < byteLength; j++) {
-          if (recordBytes[j] !== bytes[inputOffset + j]) {
-            continue FIND_CHUNK;
-          }
-        }
-        return record.str;
-      }
-    return null;
-  };
-  CachedKeyDecoder2.prototype.store = function(bytes, value) {
-    var records = this.caches[bytes.length - 1];
-    var record = { bytes, str: value };
-    if (records.length >= this.maxLengthPerKey) {
-      records[Math.random() * records.length | 0] = record;
-    } else {
-      records.push(record);
-    }
-  };
-  CachedKeyDecoder2.prototype.decode = function(bytes, inputOffset, byteLength) {
-    var cachedValue = this.find(bytes, inputOffset, byteLength);
-    if (cachedValue != null) {
-      this.hit++;
-      return cachedValue;
-    }
-    this.miss++;
-    var str = utf8.utf8DecodeJs(bytes, inputOffset, byteLength);
-    var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
-    this.store(slicedCopyOfBytes, str);
-    return str;
-  };
-  return CachedKeyDecoder2;
-}();
-exports.CachedKeyDecoder = CachedKeyDecoder;
-//# sourceMappingURL=CachedKeyDecoder.cjs.map

package/dist/__node_modules/@msgpack/msgpack/dist.es5_esm/CachedKeyDecoder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"CachedKeyDecoder.cjs","sources":["../../../../../../../node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs"],"sourcesContent":["import { utf8DecodeJs } from \"./utils/utf8.mjs\";\nvar DEFAULT_MAX_KEY_LENGTH = 16;\nvar DEFAULT_MAX_LENGTH_PER_KEY = 16;\nvar CachedKeyDecoder = /** @class */ (function () {\n    function CachedKeyDecoder(maxKeyLength, maxLengthPerKey) {\n        if (maxKeyLength === void 0) { maxKeyLength = DEFAULT_MAX_KEY_LENGTH; }\n        if (maxLengthPerKey === void 0) { maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY; }\n        this.maxKeyLength = maxKeyLength;\n        this.maxLengthPerKey = maxLengthPerKey;\n        this.hit = 0;\n        this.miss = 0;\n        // avoid `new Array(N)`, which makes a sparse array,\n        // because a sparse array is typically slower than a non-sparse array.\n        this.caches = [];\n        for (var i = 0; i < this.maxKeyLength; i++) {\n            this.caches.push([]);\n        }\n    }\n    CachedKeyDecoder.prototype.canBeCached = function (byteLength) {\n        return byteLength > 0 && byteLength <= this.maxKeyLength;\n    };\n    CachedKeyDecoder.prototype.find = function (bytes, inputOffset, byteLength) {\n        var records = this.caches[byteLength - 1];\n        FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {\n            var record = records_1[_i];\n            var recordBytes = record.bytes;\n            for (var j = 0; j < byteLength; j++) {\n                if (recordBytes[j] !== bytes[inputOffset + j]) {\n                    continue FIND_CHUNK;\n                }\n            }\n            return record.str;\n        }\n        return null;\n    };\n    CachedKeyDecoder.prototype.store = function (bytes, value) {\n        var records = this.caches[bytes.length - 1];\n        var record = { bytes: bytes, str: value };\n        if (records.length >= this.maxLengthPerKey) {\n            // `records` are full!\n            // Set `record` to an arbitrary position.\n            records[(Math.random() * records.length) | 0] = record;\n        }\n        else {\n            records.push(record);\n        }\n    };\n    CachedKeyDecoder.prototype.decode = function (bytes, inputOffset, byteLength) {\n        var cachedValue = this.find(bytes, inputOffset, byteLength);\n        if (cachedValue != null) {\n            this.hit++;\n            return cachedValue;\n        }\n        this.miss++;\n        var str = utf8DecodeJs(bytes, inputOffset, byteLength);\n        // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.\n        var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);\n        this.store(slicedCopyOfBytes, str);\n        return str;\n    };\n    return CachedKeyDecoder;\n}());\nexport { CachedKeyDecoder };\n//# sourceMappingURL=CachedKeyDecoder.mjs.map"],"names":["CachedKeyDecoder","utf8DecodeJs"],"mappings":";;;AACA,IAAI,yBAAyB;AAC7B,IAAI,6BAA6B;AAC9B,IAAC,mBAAkC,WAAY;AAC9C,WAASA,kBAAiB,cAAc,iBAAiB;AACrD,QAAI,iBAAiB,QAAQ;AAAE,qBAAe;AAAA,IAAyB;AACvE,QAAI,oBAAoB,QAAQ;AAAE,wBAAkB;AAAA,IAA6B;AACjF,SAAK,eAAe;AACpB,SAAK,kBAAkB;AACvB,SAAK,MAAM;AACX,SAAK,OAAO;AAGZ,SAAK,SAAS;AACd,aAAS,IAAI,GAAG,IAAI,KAAK,cAAc,KAAK;AACxC,WAAK,OAAO,KAAK,CAAA,CAAE;AAAA,IACtB;AAAA,EACJ;AACD,EAAAA,kBAAiB,UAAU,cAAc,SAAU,YAAY;AAC3D,WAAO,aAAa,KAAK,cAAc,KAAK;AAAA,EACpD;AACI,EAAAA,kBAAiB,UAAU,OAAO,SAAU,OAAO,aAAa,YAAY;AACxE,QAAI,UAAU,KAAK,OAAO,aAAa,CAAC;AACxC;AAAY,eAAS,KAAK,GAAG,YAAY,SAAS,KAAK,UAAU,QAAQ,MAAM;AAC3E,YAAI,SAAS,UAAU,EAAE;AACzB,YAAI,cAAc,OAAO;AACzB,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACjC,cAAI,YAAY,CAAC,MAAM,MAAM,cAAc,CAAC,GAAG;AAC3C,qBAAS;AAAA,UACZ;AAAA,QACJ;AACD,eAAO,OAAO;AAAA,MACjB;AACD,WAAO;AAAA,EACf;AACI,EAAAA,kBAAiB,UAAU,QAAQ,SAAU,OAAO,OAAO;AACvD,QAAI,UAAU,KAAK,OAAO,MAAM,SAAS,CAAC;AAC1C,QAAI,SAAS,EAAE,OAAc,KAAK,MAAK;AACvC,QAAI,QAAQ,UAAU,KAAK,iBAAiB;AAGxC,cAAS,KAAK,OAAQ,IAAG,QAAQ,SAAU,CAAC,IAAI;AAAA,IACnD,OACI;AACD,cAAQ,KAAK,MAAM;AAAA,IACtB;AAAA,EACT;AACI,EAAAA,kBAAiB,UAAU,SAAS,SAAU,OAAO,aAAa,YAAY;AAC1E,QAAI,cAAc,KAAK,KAAK,OAAO,aAAa,UAAU;AAC1D,QAAI,eAAe,MAAM;AACrB,WAAK;AACL,aAAO;AAAA,IACV;AACD,SAAK;AACL,QAAI,MAAMC,KAAY,aAAC,OAAO,aAAa,UAAU;AAErD,QAAI,oBAAoB,WAAW,UAAU,MAAM,KAAK,OAAO,aAAa,cAAc,UAAU;AACpG,SAAK,MAAM,mBAAmB,GAAG;AACjC,WAAO;AAAA,EACf;AACI,SAAOD;AACX,EAAG;;"}

package/dist/__node_modules/@msgpack/msgpack/dist.es5_esm/CachedKeyDecoder.js

@@ -1,65 +0,0 @@
-import { utf8DecodeJs } from "./utils/utf8.js";
-var DEFAULT_MAX_KEY_LENGTH = 16;
-var DEFAULT_MAX_LENGTH_PER_KEY = 16;
-var CachedKeyDecoder = function() {
-  function CachedKeyDecoder2(maxKeyLength, maxLengthPerKey) {
-    if (maxKeyLength === void 0) {
-      maxKeyLength = DEFAULT_MAX_KEY_LENGTH;
-    }
-    if (maxLengthPerKey === void 0) {
-      maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY;
-    }
-    this.maxKeyLength = maxKeyLength;
-    this.maxLengthPerKey = maxLengthPerKey;
-    this.hit = 0;
-    this.miss = 0;
-    this.caches = [];
-    for (var i = 0; i < this.maxKeyLength; i++) {
-      this.caches.push([]);
-    }
-  }
-  CachedKeyDecoder2.prototype.canBeCached = function(byteLength) {
-    return byteLength > 0 && byteLength <= this.maxKeyLength;
-  };
-  CachedKeyDecoder2.prototype.find = function(bytes, inputOffset, byteLength) {
-    var records = this.caches[byteLength - 1];
-    FIND_CHUNK:
-      for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
-        var record = records_1[_i];
-        var recordBytes = record.bytes;
-        for (var j = 0; j < byteLength; j++) {
-          if (recordBytes[j] !== bytes[inputOffset + j]) {
-            continue FIND_CHUNK;
-          }
-        }
-        return record.str;
-      }
-    return null;
-  };
-  CachedKeyDecoder2.prototype.store = function(bytes, value) {
-    var records = this.caches[bytes.length - 1];
-    var record = { bytes, str: value };
-    if (records.length >= this.maxLengthPerKey) {
-      records[Math.random() * records.length | 0] = record;
-    } else {
-      records.push(record);
-    }
-  };
-  CachedKeyDecoder2.prototype.decode = function(bytes, inputOffset, byteLength) {
-    var cachedValue = this.find(bytes, inputOffset, byteLength);
-    if (cachedValue != null) {
-      this.hit++;
-      return cachedValue;
-    }
-    this.miss++;
-    var str = utf8DecodeJs(bytes, inputOffset, byteLength);
-    var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
-    this.store(slicedCopyOfBytes, str);
-    return str;
-  };
-  return CachedKeyDecoder2;
-}();
-export {
-  CachedKeyDecoder
-};
-//# sourceMappingURL=CachedKeyDecoder.js.map

package/dist/__node_modules/@msgpack/msgpack/dist.es5_esm/CachedKeyDecoder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CachedKeyDecoder.js","sources":["../../../../../../../node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs"],"sourcesContent":["import { utf8DecodeJs } from \"./utils/utf8.mjs\";\nvar DEFAULT_MAX_KEY_LENGTH = 16;\nvar DEFAULT_MAX_LENGTH_PER_KEY = 16;\nvar CachedKeyDecoder = /** @class */ (function () {\n    function CachedKeyDecoder(maxKeyLength, maxLengthPerKey) {\n        if (maxKeyLength === void 0) { maxKeyLength = DEFAULT_MAX_KEY_LENGTH; }\n        if (maxLengthPerKey === void 0) { maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY; }\n        this.maxKeyLength = maxKeyLength;\n        this.maxLengthPerKey = maxLengthPerKey;\n        this.hit = 0;\n        this.miss = 0;\n        // avoid `new Array(N)`, which makes a sparse array,\n        // because a sparse array is typically slower than a non-sparse array.\n        this.caches = [];\n        for (var i = 0; i < this.maxKeyLength; i++) {\n            this.caches.push([]);\n        }\n    }\n    CachedKeyDecoder.prototype.canBeCached = function (byteLength) {\n        return byteLength > 0 && byteLength <= this.maxKeyLength;\n    };\n    CachedKeyDecoder.prototype.find = function (bytes, inputOffset, byteLength) {\n        var records = this.caches[byteLength - 1];\n        FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {\n            var record = records_1[_i];\n            var recordBytes = record.bytes;\n            for (var j = 0; j < byteLength; j++) {\n                if (recordBytes[j] !== bytes[inputOffset + j]) {\n                    continue FIND_CHUNK;\n                }\n            }\n            return record.str;\n        }\n        return null;\n    };\n    CachedKeyDecoder.prototype.store = function (bytes, value) {\n        var records = this.caches[bytes.length - 1];\n        var record = { bytes: bytes, str: value };\n        if (records.length >= this.maxLengthPerKey) {\n            // `records` are full!\n            // Set `record` to an arbitrary position.\n            records[(Math.random() * records.length) | 0] = record;\n        }\n        else {\n            records.push(record);\n        }\n    };\n    CachedKeyDecoder.prototype.decode = function (bytes, inputOffset, byteLength) {\n        var cachedValue = this.find(bytes, inputOffset, byteLength);\n        if (cachedValue != null) {\n            this.hit++;\n            return cachedValue;\n        }\n        this.miss++;\n        var str = utf8DecodeJs(bytes, inputOffset, byteLength);\n        // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.\n        var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);\n        this.store(slicedCopyOfBytes, str);\n        return str;\n    };\n    return CachedKeyDecoder;\n}());\nexport { CachedKeyDecoder };\n//# sourceMappingURL=CachedKeyDecoder.mjs.map"],"names":["CachedKeyDecoder"],"mappings":";AACA,IAAI,yBAAyB;AAC7B,IAAI,6BAA6B;AAC9B,IAAC,mBAAkC,WAAY;AAC9C,WAASA,kBAAiB,cAAc,iBAAiB;AACrD,QAAI,iBAAiB,QAAQ;AAAE,qBAAe;AAAA,IAAyB;AACvE,QAAI,oBAAoB,QAAQ;AAAE,wBAAkB;AAAA,IAA6B;AACjF,SAAK,eAAe;AACpB,SAAK,kBAAkB;AACvB,SAAK,MAAM;AACX,SAAK,OAAO;AAGZ,SAAK,SAAS;AACd,aAAS,IAAI,GAAG,IAAI,KAAK,cAAc,KAAK;AACxC,WAAK,OAAO,KAAK,CAAA,CAAE;AAAA,IACtB;AAAA,EACJ;AACD,EAAAA,kBAAiB,UAAU,cAAc,SAAU,YAAY;AAC3D,WAAO,aAAa,KAAK,cAAc,KAAK;AAAA,EACpD;AACI,EAAAA,kBAAiB,UAAU,OAAO,SAAU,OAAO,aAAa,YAAY;AACxE,QAAI,UAAU,KAAK,OAAO,aAAa,CAAC;AACxC;AAAY,eAAS,KAAK,GAAG,YAAY,SAAS,KAAK,UAAU,QAAQ,MAAM;AAC3E,YAAI,SAAS,UAAU,EAAE;AACzB,YAAI,cAAc,OAAO;AACzB,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACjC,cAAI,YAAY,CAAC,MAAM,MAAM,cAAc,CAAC,GAAG;AAC3C,qBAAS;AAAA,UACZ;AAAA,QACJ;AACD,eAAO,OAAO;AAAA,MACjB;AACD,WAAO;AAAA,EACf;AACI,EAAAA,kBAAiB,UAAU,QAAQ,SAAU,OAAO,OAAO;AACvD,QAAI,UAAU,KAAK,OAAO,MAAM,SAAS,CAAC;AAC1C,QAAI,SAAS,EAAE,OAAc,KAAK,MAAK;AACvC,QAAI,QAAQ,UAAU,KAAK,iBAAiB;AAGxC,cAAS,KAAK,OAAQ,IAAG,QAAQ,SAAU,CAAC,IAAI;AAAA,IACnD,OACI;AACD,cAAQ,KAAK,MAAM;AAAA,IACtB;AAAA,EACT;AACI,EAAAA,kBAAiB,UAAU,SAAS,SAAU,OAAO,aAAa,YAAY;AAC1E,QAAI,cAAc,KAAK,KAAK,OAAO,aAAa,UAAU;AAC1D,QAAI,eAAe,MAAM;AACrB,WAAK;AACL,aAAO;AAAA,IACV;AACD,SAAK;AACL,QAAI,MAAM,aAAa,OAAO,aAAa,UAAU;AAErD,QAAI,oBAAoB,WAAW,UAAU,MAAM,KAAK,OAAO,aAAa,cAAc,UAAU;AACpG,SAAK,MAAM,mBAAmB,GAAG;AACjC,WAAO;AAAA,EACf;AACI,SAAOA;AACX,EAAG;"}