chore(release): 3.0.0-alpha.0

CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [3.0.0-alpha.0](https://github.com/nuxt/vue-meta/compare/v2.3.3...v3.0.0-alpha.0) (2021-01-25)
+
+
+### Features
+
+* add amp-boilerplate as boolean attribute (resolves: [#530](https://github.com/nuxt/vue-meta/issues/530)) ([#531](https://github.com/nuxt/vue-meta/issues/531)) ([bb45319](https://github.com/nuxt/vue-meta/commit/bb453195747058d90862d2db20d6a538ef04811f))
+* add deepest resolver (wip) ([bb04dc0](https://github.com/nuxt/vue-meta/commit/bb04dc068dbcf1871bdd08eddd3bb7997b122f04))
+* add poc vue-compiler ([6d25ff2](https://github.com/nuxt/vue-meta/commit/6d25ff2f372f20af682389d2a8f85eacdc3423ed))
+* add support for attributes (wip) ([5eaa0ab](https://github.com/nuxt/vue-meta/commit/5eaa0ab5b63000a56e0f1d4460700cc6a10d3b79))
+* continued progress ([642a62c](https://github.com/nuxt/vue-meta/commit/642a62c56126f5dfdc094282f6bc179e07f022eb))
+* convert to ts (wip) ([28d3fc1](https://github.com/nuxt/vue-meta/commit/28d3fc192363b9caf0a8b25a357684e6e7ae337f))
+* first work on vue v3 composition metainfo app ([5d0eb1a](https://github.com/nuxt/vue-meta/commit/5d0eb1ab60ce476ed8a97e97d4d409e74284df9b))
+* implement first useApi basics ([b0edfbe](https://github.com/nuxt/vue-meta/commit/b0edfbe6bd638ae3404739ec881d6a0ef598e43c))
+* improve useApi ([303eae1](https://github.com/nuxt/vue-meta/commit/303eae1603a5f15611a9d66457a56b417784da8c))
+* make attributes part of the metainfo object ([5add8bf](https://github.com/nuxt/vue-meta/commit/5add8bf83f597e9576b3a4502d6d7a0f1a76014c))
+* make ssr work ([9cfde5b](https://github.com/nuxt/vue-meta/commit/9cfde5b5509e7cd0899ea450801bed753ec64075))
+* refactor of object merge & make vue-router example work ([e68b535](https://github.com/nuxt/vue-meta/commit/e68b53573e60969a0f616c053e58a90fe87ceee2))
+
+
+### Bug Fixes
+
+* resolving arrays (collections still wip) ([5c4ee7a](https://github.com/nuxt/vue-meta/commit/5c4ee7a54720ce54cd94217c2e663b350873f4f2))
+
 ### [2.3.3](https://github.com/nuxt/vue-meta/compare/v2.3.2...v2.3.3) (2020-02-26)
 
 

dist/src/Metainfo.d.ts

@@ -0,0 +1,12 @@
+import { VNodeProps } from 'vue';
+import { MetainfoActive } from './types';
+export interface MetainfoProps {
+    metainfo: MetainfoActive;
+}
+export declare const MetainfoImpl: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {}>, {}>;
+export declare const Metainfo: new () => {
+    $props: VNodeProps & MetainfoProps;
+};
+//# sourceMappingURL=Metainfo.d.ts.map

dist/src/config/default.d.ts

@@ -0,0 +1,3 @@
+import { Config } from '../types';
+export declare const defaultConfig: Config;
+//# sourceMappingURL=default.d.ts.map

dist/src/config/helpers.d.ts

@@ -0,0 +1,4 @@
+import { Config } from '../types';
+export declare function hasConfig(name: string, config: Config): boolean;
+export declare function getConfigByKey(tagOrName: string | Array<string>, key: string, config: Config): any;
+//# sourceMappingURL=helpers.d.ts.map

dist/src/config/index.d.ts

@@ -0,0 +1,4 @@
+export * from './default';
+export * from './helpers';
+export * from './tags';
+//# sourceMappingURL=index.d.ts.map

dist/src/config/tags.d.ts

@@ -0,0 +1,11 @@
+export interface TagConfig {
+    keyAttribute?: string;
+    contentAsAttribute?: boolean | string;
+    attributes: boolean | Array<string>;
+    [key: string]: any;
+}
+declare const tags: {
+    [key: string]: TagConfig;
+};
+export { tags };
+//# sourceMappingURL=tags.d.ts.map

dist/src/index.d.ts

@@ -0,0 +1,9 @@
+import * as deepestResolver from './resolvers/deepest';
+export { defaultConfig } from './config';
+export { createMetaManager } from './manager';
+export { resolveOption } from './resolvers';
+export * from './ssr';
+export * from './types';
+export * from './useApi';
+export { deepestResolver };
+//# sourceMappingURL=index.d.ts.map

dist/src/manager.d.ts

@@ -0,0 +1,8 @@
+import { VNode } from 'vue';
+import type { ResolveMethod } from './object-merge';
+import type { Manager, Config, Resolver, MetainfoActive } from './types';
+export declare const ssrAttribute = "data-vm-ssr";
+export declare const active: MetainfoActive;
+export declare function addVnode(teleports: any, to: string, _vnodes: VNode | Array<VNode>): void;
+export declare function createMetaManager(config: Config, resolver: Resolver | ResolveMethod): Manager;
+//# sourceMappingURL=manager.d.ts.map

dist/src/object-merge/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const IS_PROXY: string;
+export declare const PROXY_SOURCES: string;
+export declare const PROXY_TARGET: string;
+export declare const RESOLVE_CONTEXT: string;
+//# sourceMappingURL=constants.d.ts.map

dist/src/object-merge/index.d.ts

@@ -0,0 +1,25 @@
+export declare type MergeSource = {
+    [key: string]: any;
+};
+export declare type MergedObjectValue = boolean | number | string | MergedObject | any;
+export declare type MergedObject = {
+    [key: string]: MergedObjectValue;
+};
+export declare type PathSegments = Array<string>;
+export declare type ResolveContext = {};
+export declare type ResolveMethod = (options: Array<any>, contexts: Array<ResolveContext>, active: MergedObjectValue, key: string | number | symbol, pathSegments: PathSegments) => MergedObjectValue;
+export declare type MergeContext = {
+    resolve: ResolveMethod;
+    active: MergedObject;
+    sources: Array<MergeSource>;
+};
+export declare const createMergedObject: (resolve: ResolveMethod, active?: MergedObject) => {
+    context: MergeContext;
+    active: MergedObject;
+    resolve: ResolveMethod;
+    sources: MergeSource[];
+    addSource: (source: MergeSource, resolveContext: ResolveContext | undefined, recompute?: Boolean) => any;
+    delSource: (sourceOrProxy: MergeSource, recompute?: boolean) => boolean;
+    compute: () => void;
+};
+//# sourceMappingURL=index.d.ts.map

dist/src/object-merge/proxy.d.ts

@@ -0,0 +1,4 @@
+import type { MergeContext, MergeSource, PathSegments, ResolveContext } from '.';
+export declare const createProxy: (context: MergeContext, target: MergeSource, resolveContext: ResolveContext, pathSegments?: PathSegments) => any;
+export declare const createHandler: (context: MergeContext, resolveContext: ResolveContext, pathSegments: PathSegments) => ProxyHandler<any>;
+//# sourceMappingURL=proxy.d.ts.map

dist/src/object-merge/recompute.d.ts

@@ -0,0 +1,4 @@
+import type { MergeContext, MergeSource, MergedObject, PathSegments } from '.';
+export declare const allKeys: (source?: MergeSource | undefined, ...sources: Array<MergeSource>) => Array<string>;
+export declare const recompute: (context: MergeContext, sources?: MergeSource[] | undefined, target?: MergedObject | undefined, path?: PathSegments) => void;
+//# sourceMappingURL=recompute.d.ts.map

dist/src/render.d.ts

@@ -0,0 +1,29 @@
+import { VNode } from 'vue';
+import { TODO } from './types';
+export interface RenderContext {
+    slots: any;
+    [key: string]: TODO;
+}
+export interface GroupConfig {
+    group: string;
+    data: Array<TODO> | TODO;
+    tagNamespace?: string;
+    fullName?: string;
+    slotName?: string;
+}
+export interface SlotScopeProperties {
+    content: any;
+    metainfo: any;
+    [key: string]: any;
+}
+export declare type RenderedMetainfoNode = {
+    vnode: VNode;
+    to?: string;
+};
+export declare type RenderedMetainfo = Array<RenderedMetainfoNode>;
+export declare function renderMeta(context: RenderContext, key: string, data: TODO, config: TODO): void | RenderedMetainfo | RenderedMetainfoNode;
+export declare function renderGroup(context: RenderContext, key: string, data: TODO, config: TODO): RenderedMetainfo | RenderedMetainfoNode;
+export declare function renderTag(context: RenderContext, key: string, data: TODO, config?: TODO, groupConfig?: GroupConfig): RenderedMetainfo | RenderedMetainfoNode;
+export declare function renderAttributes(context: RenderContext, key: string, data: TODO, config?: TODO): RenderedMetainfoNode | void;
+export declare function getSlotContent({ metainfo, slots }: RenderContext, slotName: string, content: any, groupConfig?: GroupConfig): TODO;
+//# sourceMappingURL=render.d.ts.map

dist/src/resolvers/deepest.d.ts

@@ -0,0 +1,9 @@
+import { ResolveMethod } from '../object-merge';
+import { MetaContext } from '../types';
+declare type MergeContextDeepest = MetaContext & {
+    depth: number;
+};
+export declare function setup(context: MergeContextDeepest): void;
+export declare const resolve: ResolveMethod;
+export {};
+//# sourceMappingURL=deepest.d.ts.map

dist/src/resolvers/index.d.ts

@@ -0,0 +1,4 @@
+import { ResolveContext, ResolveMethod } from '../object-merge';
+export declare type ResolveOptionReducer = (accumulator: any, context: ResolveContext) => ResolveMethod;
+export declare const resolveOption: (predicament: ResolveOptionReducer) => ResolveMethod;
+//# sourceMappingURL=index.d.ts.map

dist/src/ssr.d.ts

@@ -0,0 +1,4 @@
+import type { App } from 'vue';
+import type { SSRContext } from '@vue/server-renderer';
+export declare function renderToStringWithMeta(app: App): Promise<[string, SSRContext]>;
+//# sourceMappingURL=ssr.d.ts.map

dist/src/symbols.d.ts

@@ -0,0 +1,6 @@
+import { InjectionKey } from 'vue';
+import { MetainfoActive } from './types';
+export declare const hasSymbol: boolean;
+export declare const PolySymbol: (name: string) => string | symbol;
+export declare const metaInfoKey: InjectionKey<MetainfoActive>;
+//# sourceMappingURL=symbols.d.ts.map

dist/src/types/index.d.ts

@@ -0,0 +1,59 @@
+import type { App, VNode, ComponentInternalInstance } from 'vue';
+import type { MergedObject, ResolveContext, ResolveMethod } from '../object-merge';
+export declare type TODO = any;
+export declare type MetainfoInput = {
+    [key: string]: TODO;
+};
+export declare type MetaContext = ResolveContext & {
+    vm: ComponentInternalInstance | undefined;
+};
+export interface ConfigOption {
+    tag?: string;
+    to?: string;
+    group?: boolean;
+    keyAttribute?: string;
+    valueAttribute?: string;
+    nameless?: boolean;
+    namespaced?: boolean;
+    namespacedAttribute?: boolean;
+    attributesFor?: string;
+}
+export interface Config {
+    [key: string]: ConfigOption;
+}
+export interface MetainfoProxy extends MergedObject {
+}
+export interface MetainfoActive {
+    [key: string]: TODO;
+}
+export declare type MetaProxy = {
+    meta: MetainfoProxy;
+    unmount: TODO;
+};
+export declare type ResolveSetup = (context: MetaContext) => void;
+export declare type Resolver = {
+    setup?: ResolveSetup;
+    resolve: ResolveMethod;
+};
+export declare type Manager = {
+    readonly config: Config;
+    install(app: App): void;
+    addMeta(obj: MetainfoInput, vm?: ComponentInternalInstance): MetaProxy;
+    render(ctx: {
+        slots?: any;
+    }): Array<VNode>;
+};
+declare module '@vue/runtime-core' {
+    interface ComponentInternalInstance {
+        $metaManager: Manager;
+    }
+}
+declare global {
+    namespace NodeJS {
+        interface Process {
+            client: boolean;
+            server: boolean;
+        }
+    }
+}
+//# sourceMappingURL=index.d.ts.map