xhs-mp-pack 1.1.0-beta.0

package/dist/serialization/SerializerMiddleware.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoize_1 = __importDefault(require("@/base/memoize"));
+const LAZY_TARGET = Symbol('lazy serialization target');
+const LAZY_SERIALIZED_VALUE = Symbol('lazy serialization data');
+class SerializerMiddleware {
+    serialize(data, context) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    deserialize(data, context) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    static createLazy(value, target, options = {}, serializedValue) {
+        if (SerializerMiddleware.isLazy(value, target))
+            return value;
+        const fn = typeof value === 'function' ? value : () => value;
+        fn[LAZY_TARGET] = target;
+        fn.options = options;
+        fn[LAZY_SERIALIZED_VALUE] = serializedValue;
+        return fn;
+    }
+    static isLazy(fn, target) {
+        if (typeof fn !== 'function')
+            return false;
+        const t = fn[LAZY_TARGET];
+        return target ? t === target : !!t;
+    }
+    static getLazyOptions(fn) {
+        if (typeof fn !== 'function')
+            return undefined;
+        return fn.options;
+    }
+    static getLazySerializedValue(fn) {
+        if (typeof fn !== 'function')
+            return undefined;
+        return fn[LAZY_SERIALIZED_VALUE];
+    }
+    static setLazySerializedValue(fn, value) {
+        fn[LAZY_SERIALIZED_VALUE] = value;
+    }
+    static serializeLazy(lazy, serialize) {
+        const fn = (0, memoize_1.default)(() => {
+            const r = lazy();
+            if (r && typeof r.then === 'function') {
+                return r.then(data => data && serialize(data));
+            }
+            return serialize(r);
+        });
+        fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+        // @ts-ignore
+        fn.options = lazy.options;
+        lazy[LAZY_SERIALIZED_VALUE] = fn;
+        return fn;
+    }
+    static deserializeLazy(lazy, deserialize) {
+        const fn = (0, memoize_1.default)(() => {
+            const r = lazy();
+            if (r && typeof r.then === 'function') {
+                return r.then(data => deserialize(data));
+            }
+            return deserialize(r);
+        });
+        fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+        // @ts-ignore
+        fn.options = lazy.options;
+        fn[LAZY_SERIALIZED_VALUE] = lazy;
+        return fn;
+    }
+    static unMemoizeLazy(lazy) {
+        if (!SerializerMiddleware.isLazy(lazy))
+            return lazy;
+        const fn = () => {
+            throw new Error("A lazy value that has been unmemorized can't be called again");
+        };
+        fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(lazy[LAZY_SERIALIZED_VALUE]);
+        fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+        fn.options = lazy.options;
+        return fn;
+    }
+}
+exports.default = SerializerMiddleware;

package/dist/serialization/internalSerializables.d.ts

@@ -0,0 +1,82 @@
+declare const _default: {
+    'core/cache/PackFileCacheStrategy': () => any;
+    'core/cache/ResolverCachePlugin': () => any;
+    'core/dependencies/DependenciesBlock': () => any;
+    'core/dependencies/AsyncDependenciesBlock': () => any;
+    'core/dependencies/const/ConstDependency': () => any;
+    'core/dependencies/const/CachedConstDependency': () => any;
+    'core/dependencies/CreateScriptUrlDependency': () => any;
+    'core/dependencies/commonjs/CommonJsRequireContextDependency': () => any;
+    'core/dependencies/commonjs/CommonJsExportRequireDependency': () => any;
+    'core/dependencies/commonjs/CommonJsExportsDependency': () => any;
+    'core/dependencies/commonjs/CommonJsFullRequireDependency': () => any;
+    'core/dependencies/commonjs/CommonJsRequireDependency': () => any;
+    'core/dependencies/commonjs/CommonJsSelfReferenceDependency': () => any;
+    'core/dependencies/context/ContextDependency': () => any;
+    'core/dependencies/context/ContextElementDependency': () => any;
+    'core/dependencies/css/CssImportDependency': () => any;
+    'core/dependencies/css/CssLocalIdentifierDependency': () => any;
+    'core/dependencies/css/CssSelfLocalIdentifierDependency': () => any;
+    'core/dependencies/css/CssExportDependency': () => any;
+    'core/dependencies/css/CssUrlDependency': () => any;
+    'core/dependencies/DelegatedSourceDependency': () => any;
+    'core/dependencies/entry/EntryDependency': () => any;
+    'core/dependencies/ExportsInfoDependency': () => any;
+    'core/dependencies/harmony/HarmonyAcceptDependency': () => any;
+    'core/dependencies/harmony/HarmonyAcceptImportDependency': () => any;
+    'core/dependencies/harmony/HarmonyCompatibilityDependency': () => any;
+    'core/dependencies/harmony/HarmonyExportExpressionDependency': () => any;
+    'core/dependencies/harmony/HarmonyExportHeaderDependency': () => any;
+    'core/dependencies/harmony/HarmonyExportImportedSpecifierDependency': () => any;
+    'core/dependencies/harmony/HarmonyExportSpecifierDependency': () => any;
+    'core/dependencies/harmony/HarmonyImportSideEffectDependency': () => any;
+    'core/dependencies/harmony/HarmonyImportSpecifierDependency': () => any;
+    'core/dependencies/harmony/HarmonyEvaluatedImportSpecifierDependency': () => any;
+    'core/dependencies/import/ImportContextDependency': () => any;
+    'core/dependencies/import/ImportDependency': () => any;
+    'core/dependencies/import/ImportEagerDependency': () => any;
+    'core/dependencies/import/ImportWeakDependency': () => any;
+    'core/dependencies/import/ImportMetaHotAcceptDependency': () => any;
+    'core/dependencies/import/ImportMetaHotDeclineDependency': () => any;
+    'core/dependencies/import/ImportMetaContextDependency': () => any;
+    'core/dependencies/json/JsonExportsDependency': () => any;
+    'core/dependencies/LocalModule': () => any;
+    'core/dependencies/LocalModuleDependency': () => any;
+    'core/dependencies/ModuleDecoratorDependency': () => any;
+    'core/dependencies/PureExpressionDependency': () => any;
+    'core/dependencies/RequireHeaderDependency': () => any;
+    'core/dependencies/RequireResolveContextDependency': () => any;
+    'core/dependencies/RequireResolveDependency': () => any;
+    'core/dependencies/RequireResolveHeaderDependency': () => any;
+    'core/dependencies/RuntimeRequirementsDependency': () => any;
+    'core/dependencies/StaticExportsDependency': () => any;
+    'core/dependencies/UnsupportedDependency': () => any;
+    'core/dependencies/URLDependency': () => any;
+    'core/module/Module': () => any;
+    'core/module/ContextModule': () => any;
+    'core/module/json/JsonData': () => any;
+    'core/optimize/ConcatenatedModule': () => any;
+    'core/module/ExternalModule': () => any;
+    'core/module/NormalModule': () => any;
+    'core/module/CssModule': () => any;
+    'core/module/assets/RawDataUrlModule': () => any;
+    'core/module/RawModule': () => any;
+    'core/module/ModuleGraph': () => any;
+    'base/errors/CommentCompilationWarning': () => any;
+    'base/errors/CriticalDependencyWarning': () => any;
+    'base/errors/InvalidDependenciesModuleWarning': () => any;
+    'base/errors/ModuleBuildError': () => any;
+    'base/errors/ModuleDependencyWarning': () => any;
+    'base/errors/ModuleError': () => any;
+    'base/errors/ModuleParseError': () => any;
+    'base/errors/ModuleWarning': () => any;
+    'base/errors/UnsupportedFeatureWarning': () => any;
+    'base/errors/UnhandledSchemeError': () => any;
+    'base/errors/NodeStuffInWebError': () => any;
+    'base/errors/BaseError': () => any;
+    'core/FileSystemInfo': () => any;
+    'base/InitFragment': () => any;
+    'base/LazySet': () => any;
+    'core/serialization/registerExternalSerializer': () => void;
+};
+export default _default;

package/dist/serialization/internalSerializables.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// We need to include a list of requires here
+// to allow webpack to be bundled with only static requires
+// We could use a dynamic require(`../${request}`) but this
+// would include too many modules and not every tool is able
+// to process this
+exports.default = {
+    // cache
+    'core/cache/PackFileCacheStrategy': () => require('../cache/PackFileCacheStrategy'),
+    'core/cache/ResolverCachePlugin': () => require('../cache/ResolverCachePlugin'),
+    // dependencies
+    'core/dependencies/DependenciesBlock': () => require('../dependencies/DependenciesBlock'),
+    'core/dependencies/AsyncDependenciesBlock': () => require('../dependencies/AsyncDependenciesBlock'),
+    'core/dependencies/const/ConstDependency': () => require('../dependencies/const/ConstDependency'),
+    'core/dependencies/const/CachedConstDependency': () => require('../dependencies/const/CachedConstDependency'),
+    'core/dependencies/CreateScriptUrlDependency': () => require('../dependencies/CreateScriptUrlDependency'),
+    'core/dependencies/commonjs/CommonJsRequireContextDependency': () => require('../dependencies/commonjs/CommonJsRequireContextDependency'),
+    'core/dependencies/commonjs/CommonJsExportRequireDependency': () => require('../dependencies/commonjs/CommonJsExportRequireDependency'),
+    'core/dependencies/commonjs/CommonJsExportsDependency': () => require('../dependencies/commonjs/CommonJsExportsDependency'),
+    'core/dependencies/commonjs/CommonJsFullRequireDependency': () => require('../dependencies/commonjs/CommonJsFullRequireDependency'),
+    'core/dependencies/commonjs/CommonJsRequireDependency': () => require('../dependencies/commonjs/CommonJsRequireDependency'),
+    'core/dependencies/commonjs/CommonJsSelfReferenceDependency': () => require('../dependencies/commonjs/CommonJsSelfReferenceDependency'),
+    'core/dependencies/context/ContextDependency': () => require('../dependencies/context/ContextDependency'),
+    'core/dependencies/context/ContextElementDependency': () => require('../dependencies/context/ContextElementDependency'),
+    'core/dependencies/css/CssImportDependency': () => require('../dependencies/css/CssImportDependency'),
+    'core/dependencies/css/CssLocalIdentifierDependency': () => require('../dependencies/css/CssLocalIdentifierDependency'),
+    'core/dependencies/css/CssSelfLocalIdentifierDependency': () => require('../dependencies/css/CssSelfLocalIdentifierDependency'),
+    'core/dependencies/css/CssExportDependency': () => require('../dependencies/css/CssExportDependency'),
+    'core/dependencies/css/CssUrlDependency': () => require('../dependencies/css/CssUrlDependency'),
+    'core/dependencies/DelegatedSourceDependency': () => require('../dependencies/DelegatedSourceDependency'),
+    'core/dependencies/entry/EntryDependency': () => require('../dependencies/entry/EntryDependency'),
+    'core/dependencies/ExportsInfoDependency': () => require('../dependencies/ExportsInfoDependency'),
+    'core/dependencies/harmony/HarmonyAcceptDependency': () => require('../dependencies/harmony/HarmonyAcceptDependency'),
+    'core/dependencies/harmony/HarmonyAcceptImportDependency': () => require('../dependencies/harmony/HarmonyAcceptImportDependency'),
+    'core/dependencies/harmony/HarmonyCompatibilityDependency': () => require('../dependencies/harmony/HarmonyCompatibilityDependency'),
+    'core/dependencies/harmony/HarmonyExportExpressionDependency': () => require('../dependencies/harmony/HarmonyExportExpressionDependency'),
+    'core/dependencies/harmony/HarmonyExportHeaderDependency': () => require('../dependencies/harmony/HarmonyExportHeaderDependency'),
+    'core/dependencies/harmony/HarmonyExportImportedSpecifierDependency': () => require('../dependencies/harmony/HarmonyExportImportedSpecifierDependency'),
+    'core/dependencies/harmony/HarmonyExportSpecifierDependency': () => require('../dependencies/harmony/HarmonyExportSpecifierDependency'),
+    'core/dependencies/harmony/HarmonyImportSideEffectDependency': () => require('../dependencies/harmony/HarmonyImportSideEffectDependency'),
+    'core/dependencies/harmony/HarmonyImportSpecifierDependency': () => require('../dependencies/harmony/HarmonyImportSpecifierDependency'),
+    'core/dependencies/harmony/HarmonyEvaluatedImportSpecifierDependency': () => require('../dependencies/harmony/HarmonyEvaluatedImportSpecifierDependency'),
+    'core/dependencies/import/ImportContextDependency': () => require('../dependencies/import/ImportContextDependency'),
+    'core/dependencies/import/ImportDependency': () => require('../dependencies/import/ImportDependency'),
+    'core/dependencies/import/ImportEagerDependency': () => require('../dependencies/import/ImportEagerDependency'),
+    'core/dependencies/import/ImportWeakDependency': () => require('../dependencies/import/ImportWeakDependency'),
+    'core/dependencies/import/ImportMetaHotAcceptDependency': () => require('../dependencies/import/ImportMetaHotAcceptDependency'),
+    'core/dependencies/import/ImportMetaHotDeclineDependency': () => require('../dependencies/import/ImportMetaHotDeclineDependency'),
+    'core/dependencies/import/ImportMetaContextDependency': () => require('../dependencies/import/ImportMetaContextDependency'),
+    'core/dependencies/json/JsonExportsDependency': () => require('../dependencies/json/JsonExportsDependency'),
+    'core/dependencies/LocalModule': () => require('../dependencies/LocalModule'),
+    'core/dependencies/LocalModuleDependency': () => require('../dependencies/LocalModuleDependency'),
+    'core/dependencies/ModuleDecoratorDependency': () => require('../dependencies/ModuleDecoratorDependency'),
+    'core/dependencies/PureExpressionDependency': () => require('../dependencies/PureExpressionDependency'),
+    'core/dependencies/RequireHeaderDependency': () => require('../dependencies/RequireHeaderDependency'),
+    'core/dependencies/RequireResolveContextDependency': () => require('../dependencies/RequireResolveContextDependency'),
+    'core/dependencies/RequireResolveDependency': () => require('../dependencies/RequireResolveDependency'),
+    'core/dependencies/RequireResolveHeaderDependency': () => require('../dependencies/RequireResolveHeaderDependency'),
+    'core/dependencies/RuntimeRequirementsDependency': () => require('../dependencies/RuntimeRequirementsDependency'),
+    'core/dependencies/StaticExportsDependency': () => require('../dependencies/StaticExportsDependency'),
+    'core/dependencies/UnsupportedDependency': () => require('../dependencies/UnsupportedDependency'),
+    'core/dependencies/URLDependency': () => require('../dependencies/URLDependency'),
+    // module
+    'core/module/Module': () => require('../module/Module'),
+    'core/module/ContextModule': () => require('../module/ContextModule'),
+    'core/module/json/JsonData': () => require('../module/json/JsonData'),
+    'core/optimize/ConcatenatedModule': () => require('../plugins/optimize/ConcatenatedModule'),
+    'core/module/ExternalModule': () => require('../module/ExternalModule'),
+    'core/module/NormalModule': () => require('../module/NormalModule'),
+    'core/module/CssModule': () => require('../module/CssModule'),
+    'core/module/assets/RawDataUrlModule': () => require('../module/asset/RawDataUrlModule'),
+    'core/module/RawModule': () => require('../module/RawModule'),
+    'core/module/ModuleGraph': () => require('../module/ModuleGraph'),
+    // errors or warnings
+    'base/errors/CommentCompilationWarning': () => require('../../base/errors/CommentCompilationWarning'),
+    'base/errors/CriticalDependencyWarning': () => require('../../base/errors/CriticalDependencyWarning'),
+    'base/errors/InvalidDependenciesModuleWarning': () => require('../../base/errors/InvalidDependenciesModuleWarning'),
+    'base/errors/ModuleBuildError': () => require('../../base/errors/ModuleBuildError'),
+    'base/errors/ModuleDependencyWarning': () => require('../../base/errors/ModuleDependencyWarning'),
+    'base/errors/ModuleError': () => require('../../base/errors/ModuleError'),
+    'base/errors/ModuleParseError': () => require('../../base/errors/ModuleParseError'),
+    'base/errors/ModuleWarning': () => require('../../base/errors/ModuleWarning'),
+    'base/errors/UnsupportedFeatureWarning': () => require('../../base/errors/UnsupportedFeatureWarning'),
+    'base/errors/UnhandledSchemeError': () => require('../../base/errors/UnhandledSchemeError'),
+    'base/errors/NodeStuffInWebError': () => require('../../base/errors/NodeStuffInWebError'),
+    'base/errors/BaseError': () => require('../../base/errors/BaseError'),
+    'core/FileSystemInfo': () => require('../FileSystemInfo'),
+    'base/InitFragment': () => require('../../base/InitFragment'),
+    'base/LazySet': () => require('../../base/LazySet'),
+    'core/serialization/registerExternalSerializer': () => {
+        // already registered
+    },
+};

package/dist/serialization/makeSerializable.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (Constructor: any, request: any, name?: string | null) => void;
+export default _default;

package/dist/serialization/makeSerializable.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Serialization_1 = __importDefault(require("./Serialization"));
+class ClassSerializer {
+    constructor(Constructor) {
+        this.Constructor = Constructor;
+    }
+    serialize(obj, context) {
+        obj.serialize(context);
+    }
+    deserialize(context) {
+        if (typeof this.Constructor.deserialize === 'function') {
+            return this.Constructor.deserialize(context);
+        }
+        const obj = new this.Constructor();
+        obj.deserialize(context);
+        return obj;
+    }
+}
+exports.default = (Constructor, request, name = null) => {
+    Serialization_1.default.register(Constructor, request, name, new ClassSerializer(Constructor));
+};

package/dist/serialization/middlewares/BinaryMiddleware.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import SerializerMiddleware from '../SerializerMiddleware';
+declare class BinaryMiddleware extends SerializerMiddleware {
+    serialize(data: any, context: any): Buffer[];
+    _serializeLazy(fn: any, context: any): any;
+    _serialize(data: any, context: any, allocationScope?: any): Buffer[];
+    deserialize(data: any, context: any): any;
+    _createLazyDeserialized(content: any, context: any): any;
+    _deserializeLazy(fn: any, context: any): any;
+    _deserialize(data: any, context: any): any;
+}
+export default BinaryMiddleware;