9764310597

Committed 02 Jul 2024 04:03PM UTC coverage: 31.982% (+0.06%) from 31.921%

Build # 9764310597

Build Type

Pull #9466

github

Committed by

Will-Howard

Commit Message

handle case where mutation doesn't affect subscribedToDigest

Pull Request Pull Request #9466: Add script for hard-deleting accounts

Run Details

4885 of 39747 branches covered (12.29%)

Branch coverage included in aggregate %.

20 of 123 new or added lines in 7 files covered. (16.26%)

1235 existing lines in 43 files now uncovered.

28395 of 64310 relevant lines covered (44.15%)

180.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.2

/packages/lesswrong/lib/editor/make_editable.ts

import { documentIsNotDeleted, userOwns } from '../vulcan-users/permissions';
import { camelCaseify } from '../vulcan-lib/utils';
import { ContentType, getOriginalContents } from '../collections/revisions/schema'
import { accessFilterMultiple, addFieldsDict } from '../utils/schemaUtils';
import SimpleSchema from 'simpl-schema'
import { getWithLoader } from '../loaders';
import { isFriendlyUI } from '../../themes/forumTheme';

export const RevisionStorageType = new SimpleSchema({
  originalContents: {type: ContentType, optional: true},
  userId: {type: String, optional: true},
  commitMessage: {type: String, optional: true},
  html: {type: String, optional: true, denormalized: true},
  updateType: {type: String, optional: true, allowedValues: ['initial', 'patch', 'minor', 'major']},
  version: {type: String, optional: true},
  editedAt: {type: Date, optional: true},
  wordCount: {type: SimpleSchema.Integer, optional: true, denormalized: true},
  // dataWithDiscardedSuggestions is not actually stored in the database, just passed 
  // through the mutation so that we can provide html that doesn't include private
  // information.
  dataWithDiscardedSuggestions: {type: String, optional: true, nullable: true}
})

type EditableFieldName<N extends CollectionNameString> =
  keyof ObjectsByCollectionName[N] & string;

type MakeEditableOptionsFieldName<N extends CollectionNameString> = {
  fieldName?: EditableFieldName<N>,
  normalized?: false,
} | {
  fieldName?: string,
  normalized: true,
};

export type MakeEditableOptions<N extends CollectionNameString> = {
  commentEditor?: boolean,
  commentStyles?: boolean,
  commentLocalStorage?: boolean,
  getLocalStorageId?: null | ((doc: any, name: string) => {id: string, verify: boolean}),
  formGroup?: any,
  permissions?: {
    canRead?: any,
    canUpdate?: any,
    canCreate?: any,
  },
  label?: string,
  order?: number,
  hideControls?: boolean,
  hintText?: string,
  pingbacks?: boolean,
  revisionsHaveCommitMessages?: boolean,
  hidden?: boolean,
  hasToc?: boolean,
} & MakeEditableOptionsFieldName<N>;

export const defaultEditorPlaceholder = isFriendlyUI ?
`Highlight text to format it. Type # to reference a post, @ to mention someone.` :  
  
`Text goes here! See lesswrong.com/editor for info about everything the editor can do.

lesswrong.com/editor covers formatting, draft-sharing, co-authoring, LaTeX, footnotes, tagging users and posts, spoiler tags, Markdown, tables, crossposting, and more.`;


export const debateEditorPlaceholder = 
`Enter your first dialogue comment here, add other participants as co-authors, then save this as a draft.

Other participants will be able to participate by leaving comments on the draft, which will automatically be converted into dialogue responses.`;

export const linkpostEditorPlaceholder =
`Share an excerpt, a summary, or a note about why you like the post.

You can paste the whole post if you have permission from the author, or add them as co-author in the Options below.
`

export const questionEditorPlaceholder =
`Kick off a discussion or solicit answers to something you’re confused about.`

const defaultOptions: MakeEditableOptions<CollectionNameString> = {
  // Determines whether to use the comment editor configuration (e.g. Toolbars)
  commentEditor: false,
  // Determines whether to use the comment editor styles (e.g. Fonts)
  commentStyles: false,
  // Determines whether to use the comment local storage restoration system
  commentLocalStorage: false,
  // Given a document and a field name, return:
  // {
  //   id: The name to use for storing drafts related to this document in
  //     localStorage. This may be combined with an editor-type prefix.
  //   verify: Whether to prompt before restoring a draft (as opposed to just
  //     always restoring it).
  // }
  getLocalStorageId: null,
  permissions: {
    canRead: [documentIsNotDeleted],
    canUpdate: [userOwns, 'sunshineRegiment', 'admins'],
    canCreate: ['members']
  },
  order: 0,
  hintText: defaultEditorPlaceholder,
  pingbacks: false,
  revisionsHaveCommitMessages: false,
}

export const editableCollections = new Set<CollectionNameString>()
export const editableCollectionsFields: Record<CollectionNameString,Array<string>> = {} as any;
export const editableCollectionsFieldOptions: Record<CollectionNameString, Record<string, MakeEditableOptions<CollectionNameString>>> = {} as any;
let editableFieldsSealed = false;
export function sealEditableFields() { editableFieldsSealed=true }

const buildEditableResolver = <N extends CollectionNameString>(
  collection: CollectionBase<N>,
  fieldName: string,
  normalized: boolean,
): CollectionFieldResolveAs<N> => {
  if (normalized) {
    return {
      type: "Revision",
      arguments: "version: String",
      resolver: async (
        doc: ObjectsByCollectionName[N],
        _args: {version?: string},
        context: ResolverContext,
      ): Promise<DbRevision|null> => {
        const {currentUser, Revisions} = context;
        const {checkAccess} = Revisions;
        const revision = await Revisions.findOne({
          _id: doc[`${fieldName}_latest` as keyof ObjectsByCollectionName[N]],
        });
        return revision && await checkAccess(currentUser, revision, context)
          ? revision
          : null;
      },
      sqlResolver: ({field, resolverArg, join}) => join({
        table: "Revisions",
        type: "left",
        on: {
          _id: `COALESCE(${resolverArg("version")}, ${field(`${fieldName}_latest` as FieldName<N>)})`,
        },
        resolver: (revisionField) => revisionField("*"),
      }),
    };
  }

  return {
    type: "Revision",
    arguments: "version: String",
    resolver: async (
      doc: ObjectsByCollectionName[N],
      {version}: {version?: string},
      context: ResolverContext,
    ): Promise<DbRevision|null> => {
      const {currentUser, Revisions} = context;
      if (version) {
        const {checkAccess} = Revisions;
        if (version === "draft") {
          // If version is the special string "draft", that means
          // instead of returning the latest non-draft version
          // (what we'd normally do), we instead return the latest
          // version period, including draft versions.
          const revision = await Revisions.findOne({
            documentId: doc._id,
            fieldName,
          }, {sort: {editedAt: -1}});
          return revision && await checkAccess(currentUser, revision, context)
            ? revision
            : null;
        } else {
          const revision = await Revisions.findOne({
            documentId: doc._id,
            version,
            fieldName,
          });
          return revision && await checkAccess(currentUser, revision, context)
            ? revision
            : null;
        }
      }

      const typedFieldName = fieldName as keyof ObjectsByCollectionName[N];
      const docField = doc[typedFieldName] as EditableFieldContents;
      if (!docField) {
        return null;
      }

      const result = {
        ...docField,
        // we're specifying these fields manually because docField doesn't have
        // them, or because we need to control the permissions on them.
        // The reason we need to return documentId and collectionName is because
        // this entire result gets recursively resolved by revision field
        // resolvers, and those resolvers depend on these fields existing.
        _id: `${doc._id}_${fieldName}`, //HACK
        documentId: doc._id,
        collectionName: collection.collectionName,
        editedAt: new Date(docField?.editedAt ?? Date.now()),
        originalContents: getOriginalContents(
          context.currentUser,
          doc,
          docField.originalContents,
        ),
      } as DbRevision;
      // HACK: Pretend that this denormalized field is a DbRevision (even though
      // it's missing an _id and some other fields)
      return result
    },
  };
}

export const makeEditable = <N extends CollectionNameString>({
  collection,
  options = {},
}: {
  collection: CollectionBase<N>,
  options: MakeEditableOptions<N>,
}) => {
  if (editableFieldsSealed)
    throw new Error("Called makeEditable after addAllEditableCallbacks already ran; this indicates a problem with import order");
  
  options = {...defaultOptions, ...options}
  const {
    commentEditor,
    commentStyles,
    formGroup,
    permissions,
    fieldName = "contents" as EditableFieldName<N>,
    label,
    hintText,
    order,
    hidden = false,
    hideControls = false,
    pingbacks = false,
    normalized = false,
    //revisionsHaveCommitMessages, //unused in this function (but used elsewhere)
  } = options

  const collectionName = collection.options.collectionName;
  const getLocalStorageId = options.getLocalStorageId || ((doc: any, name: string): {id: string, verify: boolean} => {
    const { _id, conversationId } = doc
    if (_id && name) { return {id: `${_id}${name}`, verify: true}}
    else if (_id) { return {id: _id, verify: true }}
    else if (conversationId) { return {id: conversationId, verify: true }}
    else if (name) { return {id: `${collectionName}_new_${name}`, verify: true }}
    else {
      throw Error(`Can't get storage ID for this document: ${doc}`)
    }
  });
  
  editableCollections.add(collectionName)
  editableCollectionsFields[collectionName] = [
    ...(editableCollectionsFields[collectionName] || []),
    fieldName
  ]
  editableCollectionsFieldOptions[collectionName] = {
    ...editableCollectionsFieldOptions[collectionName],
    [fieldName]: {
      ...options,
      fieldName,
      getLocalStorageId
    },
  };

  addFieldsDict(collection, {
    [fieldName]: {
      type: RevisionStorageType,
      optional: true,
      logChanges: false, //Logged via Revisions rather than LWEvents
      typescriptType: "EditableFieldContents",
      group: formGroup,
      ...permissions,
      order,
      hidden,
      control: 'EditorFormComponent',
      resolveAs: buildEditableResolver(collection, fieldName, normalized),
      form: {
        label,
        hintText,
        fieldName,
        collectionName,
        commentEditor,
        commentStyles,
        hideControls,
      },
    },

    [`${fieldName}_latest`]: {
      type: String,
      canRead: ['guests'],
      optional: true,
    },

    [fieldName === "contents" ? "revisions" : camelCaseify(`${fieldName}Revisions`)]: {
      type: Object,
      canRead: ['guests'],
      optional: true,
      resolveAs: {
        type: '[Revision]',
        arguments: 'limit: Int = 5',
        resolver: async (post: ObjectsByCollectionName[N], args: { limit: number }, context: ResolverContext) => {
          const { limit } = args;
          const { currentUser, Revisions } = context;

          // getWithLoader is used here to fix a performance bug for a particularly nasty bot which resolves `revisions` for thousands of comments.
          // Previously, this would cause a query for every comment whereas now it only causes one (admittedly quite slow) query
          const loaderResults = await getWithLoader(
            context,
            Revisions,
            `revisionsByDocumentId_${fieldName}_${limit}`,
            {fieldName},
            "documentId",
            post._id,
            {sort: {editedAt: -1}, limit},
          );

          return await accessFilterMultiple(currentUser, Revisions, loaderResults, context);
        }
      }
    },
    
    [fieldName === "contents" ? "version" : camelCaseify(`${fieldName}Version`)]: {
      type: String,
      canRead: ['guests'],
      optional: true,
      resolveAs: {
        type: 'String',
        resolver: (post: ObjectsByCollectionName[N]): string => {
          return (post as AnyBecauseTodo)[fieldName]?.version
        }
      }
    }
  });
  
  if (pingbacks) {
    addFieldsDict(collection, {
      // Dictionary from collection name to array of distinct referenced
      // document IDs in that collection, in order of appearance
      pingbacks: {
        type: Object,
        canRead: 'guests',
        optional: true,
        hidden: true,
        denormalized: true,
      },
      "pingbacks.$": {
        type: Array,
      },
      "pingbacks.$.$": {
        type: String,
      },
    });
  }
}

1	import { documentIsNotDeleted, userOwns } from '../vulcan-users/permissions';	1,247✔
2	import { camelCaseify } from '../vulcan-lib/utils';	28✔
3	import { ContentType, getOriginalContents } from '../collections/revisions/schema'	28✔
4	import { accessFilterMultiple, addFieldsDict } from '../utils/schemaUtils';	28✔
5	import SimpleSchema from 'simpl-schema'	28✔
6	import { getWithLoader } from '../loaders';	28✔
7	import { isFriendlyUI } from '../../themes/forumTheme';	28✔
8
9	export const RevisionStorageType = new SimpleSchema({	28✔
10	originalContents: {type: ContentType, optional: true},
11	userId: {type: String, optional: true},
12	commitMessage: {type: String, optional: true},
13	html: {type: String, optional: true, denormalized: true},
14	updateType: {type: String, optional: true, allowedValues: ['initial', 'patch', 'minor', 'major']},
15	version: {type: String, optional: true},
16	editedAt: {type: Date, optional: true},
17	wordCount: {type: SimpleSchema.Integer, optional: true, denormalized: true},
18	// dataWithDiscardedSuggestions is not actually stored in the database, just passed
19	// through the mutation so that we can provide html that doesn't include private
20	// information.
21	dataWithDiscardedSuggestions: {type: String, optional: true, nullable: true}
22	})
23
24	type EditableFieldName<N extends CollectionNameString> =
25	keyof ObjectsByCollectionName[N] & string;
26
27	type MakeEditableOptionsFieldName<N extends CollectionNameString> = {
28	fieldName?: EditableFieldName<N>,
29	normalized?: false,
30	} \| {
31	fieldName?: string,
32	normalized: true,
33	};
34
35	export type MakeEditableOptions<N extends CollectionNameString> = {
36	commentEditor?: boolean,
37	commentStyles?: boolean,
38	commentLocalStorage?: boolean,
39	getLocalStorageId?: null \| ((doc: any, name: string) => {id: string, verify: boolean}),
40	formGroup?: any,
41	permissions?: {
42	canRead?: any,
43	canUpdate?: any,
44	canCreate?: any,
45	},
46	label?: string,
47	order?: number,
48	hideControls?: boolean,
49	hintText?: string,
50	pingbacks?: boolean,
51	revisionsHaveCommitMessages?: boolean,
52	hidden?: boolean,
53	hasToc?: boolean,
54	} & MakeEditableOptionsFieldName<N>;
55
56	export const defaultEditorPlaceholder = isFriendlyUI ?	28✔
57	`Highlight text to format it. Type # to reference a post, @ to mention someone.` :	28!
58
59	`Text goes here! See lesswrong.com/editor for info about everything the editor can do.
60
61	lesswrong.com/editor covers formatting, draft-sharing, co-authoring, LaTeX, footnotes, tagging users and posts, spoiler tags, Markdown, tables, crossposting, and more.`;
62
63
64	export const debateEditorPlaceholder =
65	`Enter your first dialogue comment here, add other participants as co-authors, then save this as a draft.	28✔
66
67	Other participants will be able to participate by leaving comments on the draft, which will automatically be converted into dialogue responses.`;
68
69	export const linkpostEditorPlaceholder =
70	`Share an excerpt, a summary, or a note about why you like the post.	28✔
71
72	You can paste the whole post if you have permission from the author, or add them as co-author in the Options below.
73	`
74
75	export const questionEditorPlaceholder =
76	`Kick off a discussion or solicit answers to something you’re confused about.`	28✔
77
78	const defaultOptions: MakeEditableOptions<CollectionNameString> = {	28✔
79	// Determines whether to use the comment editor configuration (e.g. Toolbars)
80	commentEditor: false,
81	// Determines whether to use the comment editor styles (e.g. Fonts)
82	commentStyles: false,
83	// Determines whether to use the comment local storage restoration system
84	commentLocalStorage: false,
85	// Given a document and a field name, return:
86	// {
87	// id: The name to use for storing drafts related to this document in
88	// localStorage. This may be combined with an editor-type prefix.
89	// verify: Whether to prompt before restoring a draft (as opposed to just
90	// always restoring it).
91	// }
92	getLocalStorageId: null,
93	permissions: {
94	canRead: [documentIsNotDeleted],
95	canUpdate: [userOwns, 'sunshineRegiment', 'admins'],
96	canCreate: ['members']
97	},
98	order: 0,
99	hintText: defaultEditorPlaceholder,
100	pingbacks: false,
101	revisionsHaveCommitMessages: false,
102	}
103
104	export const editableCollections = new Set<CollectionNameString>()	28✔
105	export const editableCollectionsFields: Record<CollectionNameString,Array<string>> = {} as any;	28✔
106	export const editableCollectionsFieldOptions: Record<CollectionNameString, Record<string, MakeEditableOptions<CollectionNameString>>> = {} as any;	28✔
107	let editableFieldsSealed = false;	28✔
108	export function sealEditableFields() { editableFieldsSealed=true }	16✔
109
110	const buildEditableResolver = <N extends CollectionNameString>(	28✔
111	collection: CollectionBase<N>,
112	fieldName: string,
113	normalized: boolean,
114	): CollectionFieldResolveAs<N> => {
115	if (normalized) {	523✔
116	return {	24✔
117	type: "Revision",
118	arguments: "version: String",
119	resolver: async (
120	doc: ObjectsByCollectionName[N],
121	_args: {version?: string},
122	context: ResolverContext,
123	): Promise<DbRevision\|null> => {
UNCOV 124	const {currentUser, Revisions} = context;	×
125	const {checkAccess} = Revisions;	×
126	const revision = await Revisions.findOne({	×
127	_id: doc[`${fieldName}_latest` as keyof ObjectsByCollectionName[N]],
128	});
UNCOV 129	return revision && await checkAccess(currentUser, revision, context)	×
130	? revision	×
131	: null;
132	},
UNCOV 133	sqlResolver: ({field, resolverArg, join}) => join({	×
134	table: "Revisions",
135	type: "left",
136	on: {
137	_id: `COALESCE(${resolverArg("version")}, ${field(`${fieldName}_latest` as FieldName<N>)})`,
138	},
UNCOV 139	resolver: (revisionField) => revisionField("*"),	×
140	}),
141	};
142	}
143
144	return {	499✔
145	type: "Revision",
146	arguments: "version: String",
147	resolver: async (
148	doc: ObjectsByCollectionName[N],
149	{version}: {version?: string},
150	context: ResolverContext,
151	): Promise<DbRevision\|null> => {
152	const {currentUser, Revisions} = context;	12✔
153	if (version) {	12!
UNCOV 154	const {checkAccess} = Revisions;	×
155	if (version === "draft") {	×
156	// If version is the special string "draft", that means
157	// instead of returning the latest non-draft version
158	// (what we'd normally do), we instead return the latest
159	// version period, including draft versions.
UNCOV 160	const revision = await Revisions.findOne({	×
161	documentId: doc._id,
162	fieldName,
163	}, {sort: {editedAt: -1}});
UNCOV 164	return revision && await checkAccess(currentUser, revision, context)	×
165	? revision	×
166	: null;
167	} else {
UNCOV 168	const revision = await Revisions.findOne({	×
169	documentId: doc._id,
170	version,
171	fieldName,
172	});
UNCOV 173	return revision && await checkAccess(currentUser, revision, context)	×
174	? revision	×
175	: null;
176	}
177	}
178
179	const typedFieldName = fieldName as keyof ObjectsByCollectionName[N];	12✔
180	const docField = doc[typedFieldName] as EditableFieldContents;	12✔
181	if (!docField) {	12✔
182	return null;	6✔
183	}
184
185	const result = {	6✔
186	...docField,
187	// we're specifying these fields manually because docField doesn't have
188	// them, or because we need to control the permissions on them.
189	// The reason we need to return documentId and collectionName is because
190	// this entire result gets recursively resolved by revision field
191	// resolvers, and those resolvers depend on these fields existing.
192	_id: `${doc._id}_${fieldName}`, //HACK
193	documentId: doc._id,
194	collectionName: collection.collectionName,
195	editedAt: new Date(docField?.editedAt ?? Date.now()),	12!
196	originalContents: getOriginalContents(
197	context.currentUser,
198	doc,
199	docField.originalContents,
200	),
201	} as DbRevision;
202	// HACK: Pretend that this denormalized field is a DbRevision (even though
203	// it's missing an _id and some other fields)
204	return result	6✔
205	},
206	};
207	}
208
209	export const makeEditable = <N extends CollectionNameString>({	28✔
210	collection,
211	options = {},	×
212	}: {
213	collection: CollectionBase<N>,
214	options: MakeEditableOptions<N>,
215	}) => {
216	if (editableFieldsSealed)	523!
UNCOV 217	throw new Error("Called makeEditable after addAllEditableCallbacks already ran; this indicates a problem with import order");	×
218
219	options = {...defaultOptions, ...options}	523✔
220	const {
221	commentEditor,
222	commentStyles,
223	formGroup,
224	permissions,
225	fieldName = "contents" as EditableFieldName<N>,	242✔
226	label,
227	hintText,
228	order,
229	hidden = false,	371✔
230	hideControls = false,	428✔
231	pingbacks = false,	×
232	normalized = false,	499✔
233	//revisionsHaveCommitMessages, //unused in this function (but used elsewhere)
234	} = options	523✔
235
236	const collectionName = collection.options.collectionName;	523✔
237	const getLocalStorageId = options.getLocalStorageId \|\| ((doc: any, name: string): {id: string, verify: boolean} => {	523✔
UNCOV 238	const { _id, conversationId } = doc	×
UNCOV 239	if (_id && name) { return {id: `${_id}${name}`, verify: true}}	×
240	else if (_id) { return {id: _id, verify: true }}	×
241	else if (conversationId) { return {id: conversationId, verify: true }}	×
242	else if (name) { return {id: `${collectionName}_new_${name}`, verify: true }}	×
243	else {
244	throw Error(`Can't get storage ID for this document: ${doc}`)	×
245	}
246	});
247
248	editableCollections.add(collectionName)	523✔
249	editableCollectionsFields[collectionName] = [	523✔
250	...(editableCollectionsFields[collectionName] \|\| []),	853✔
251	fieldName
252	]
253	editableCollectionsFieldOptions[collectionName] = {	523✔
254	...editableCollectionsFieldOptions[collectionName],
255	[fieldName]: {
256	...options,
257	fieldName,
258	getLocalStorageId
259	},
260	};
261
262	addFieldsDict(collection, {	523✔
263	[fieldName]: {
264	type: RevisionStorageType,
265	optional: true,
266	logChanges: false, //Logged via Revisions rather than LWEvents
267	typescriptType: "EditableFieldContents",
268	group: formGroup,
269	...permissions,
270	order,
271	hidden,
272	control: 'EditorFormComponent',
273	resolveAs: buildEditableResolver(collection, fieldName, normalized),
274	form: {
275	label,
276	hintText,
277	fieldName,
278	collectionName,
279	commentEditor,
280	commentStyles,
281	hideControls,
282	},
283	},
284
285	[`${fieldName}_latest`]: {
286	type: String,
287	canRead: ['guests'],
288	optional: true,
289	},
290
291	[fieldName === "contents" ? "revisions" : camelCaseify(`${fieldName}Revisions`)]: {	523✔
292	type: Object,
293	canRead: ['guests'],
294	optional: true,
295	resolveAs: {
296	type: '[Revision]',
297	arguments: 'limit: Int = 5',
298	resolver: async (post: ObjectsByCollectionName[N], args: { limit: number }, context: ResolverContext) => {
299	const { limit } = args;	2✔
300	const { currentUser, Revisions } = context;	2✔
301
302	// getWithLoader is used here to fix a performance bug for a particularly nasty bot which resolves `revisions` for thousands of comments.
303	// Previously, this would cause a query for every comment whereas now it only causes one (admittedly quite slow) query
304	const loaderResults = await getWithLoader(	2✔
305	context,
306	Revisions,
307	`revisionsByDocumentId_${fieldName}_${limit}`,
308	{fieldName},
309	"documentId",
310	post._id,
311	{sort: {editedAt: -1}, limit},
312	);
313
314	return await accessFilterMultiple(currentUser, Revisions, loaderResults, context);	2✔
315	}
316	}
317	},
318
319	[fieldName === "contents" ? "version" : camelCaseify(`${fieldName}Version`)]: {	523✔
320	type: String,
321	canRead: ['guests'],
322	optional: true,
323	resolveAs: {
324	type: 'String',
325	resolver: (post: ObjectsByCollectionName[N]): string => {
326	return (post as AnyBecauseTodo)[fieldName]?.version	2!
327	}
328	}
329	}
330	});
331
332	if (pingbacks) {	523✔
333	addFieldsDict(collection, {	67✔
334	// Dictionary from collection name to array of distinct referenced
335	// document IDs in that collection, in order of appearance
336	pingbacks: {
337	type: Object,
338	canRead: 'guests',
339	optional: true,
340	hidden: true,
341	denormalized: true,
342	},
343	"pingbacks.$": {
344	type: Array,
345	},
346	"pingbacks.$.$": {
347	type: String,
348	},
349	});
350	}
351	}

ForumMagnum / ForumMagnum / 9764310597

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous