diff options
Diffstat (limited to 'js/dojo-1.6/dojox/data/GoogleSearchStore.xd.js')
| -rw-r--r-- | js/dojo-1.6/dojox/data/GoogleSearchStore.xd.js | 676 |
1 files changed, 676 insertions, 0 deletions
diff --git a/js/dojo-1.6/dojox/data/GoogleSearchStore.xd.js b/js/dojo-1.6/dojox/data/GoogleSearchStore.xd.js new file mode 100644 index 0000000..971c6bc --- /dev/null +++ b/js/dojo-1.6/dojox/data/GoogleSearchStore.xd.js @@ -0,0 +1,676 @@ +/*
+ Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+ Available via Academic Free License >= 2.1 OR the modified BSD license.
+ see: http://dojotoolkit.org/license for details
+*/
+
+
+dojo._xdResourceLoaded(function(dojo, dijit, dojox){
+return {depends: [["provide", "dojox.data.GoogleSearchStore"],
+["require", "dojo.io.script"],
+["provide", "dojox.data.GoogleWebSearchStore"],
+["provide", "dojox.data.GoogleBlogSearchStore"],
+["provide", "dojox.data.GoogleLocalSearchStore"],
+["provide", "dojox.data.GoogleVideoSearchStore"],
+["provide", "dojox.data.GoogleNewsSearchStore"],
+["provide", "dojox.data.GoogleBookSearchStore"],
+["provide", "dojox.data.GoogleImageSearchStore"]],
+defineResource: function(dojo, dijit, dojox){if(!dojo._hasResource["dojox.data.GoogleSearchStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.data.GoogleSearchStore"] = true;
+dojo.provide("dojox.data.GoogleSearchStore");
+dojo.require("dojo.io.script");
+
+
+
+dojo.provide("dojox.data.GoogleWebSearchStore");
+dojo.provide("dojox.data.GoogleBlogSearchStore");
+dojo.provide("dojox.data.GoogleLocalSearchStore");
+dojo.provide("dojox.data.GoogleVideoSearchStore");
+dojo.provide("dojox.data.GoogleNewsSearchStore");
+dojo.provide("dojox.data.GoogleBookSearchStore");
+dojo.provide("dojox.data.GoogleImageSearchStore");
+
+dojo.experimental("dojox.data.GoogleSearchStore");
+
+dojo.declare("dojox.data.GoogleSearchStore",null,{
+ // summary:
+ // A data store for retrieving search results from Google.
+ // This data store acts as a base class for Google searches,
+ // and has a number of child data stores that implement different
+ // searches. This store defaults to searching the web, and is functionally
+ // identical to the dojox.data.GoogleWebSearchStore object.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>url - The URL for the item</li>
+ // <li>unescapedUrl - The URL for the item, with URL escaping. This is often more readable</li>
+ // <li>visibleUrl - The URL with no protocol specified.
+ // <li>cacheUrl - The URL to the copy of the document cached by Google
+ // <li>title - The page title in HTML format.</li>
+ // <li>titleNoFormatting - The page title in plain text</li>
+ // <li>content - A snippet of information about the page</li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+ constructor: function(/*Object*/args){
+ // summary:
+ // Initializer for the GoogleSearchStore store.
+ // description:
+ // The GoogleSearchStore is a Datastore interface to
+ // the Google search service. The constructor accepts the following arguments:
+ // <ul>
+ // <li>label - the label attribute to use. Defaults to titleNoFormatting</li>
+ // <li>key - The API key to use. This is optional</li>
+ // <li>lang - The language locale to use. Defaults to the browser locale</li>
+ // </ul>
+
+ if(args){
+ if(args.label){
+ this.label = args.label;
+ }
+ if(args.key){
+ this._key = args.key;
+ }
+ if(args.lang){
+ this._lang = args.lang;
+ }
+ if("urlPreventCache" in args){
+ this.urlPreventCache = args.urlPreventCache?true:false;
+ }
+ }
+ this._id = dojox.data.GoogleSearchStore.prototype._id++;
+ },
+
+ // _id: Integer
+ // A unique identifier for this store.
+ _id: 0,
+
+ // _requestCount: Integer
+ // A counter for the number of requests made. This is used to define
+ // the callback function that GoogleSearchStore will use.
+ _requestCount: 0,
+
+ // _googleUrl: String
+ // The URL to Googles search web service.
+ _googleUrl: "http://ajax.googleapis.com/ajax/services/search/",
+
+ // _storeRef: String
+ // The internal reference added to each item pointing at the store which owns it.
+ _storeRef: "_S",
+
+ // _attributes: Array
+ // The list of attributes that this store supports
+ _attributes: [ "unescapedUrl", "url", "visibleUrl", "cacheUrl", "title",
+ "titleNoFormatting", "content", "estimatedResultCount"],
+
+ // _aggregtedAttributes: Hash
+ // Maps per-query aggregated attributes that this store supports to the result keys that they come from.
+ _aggregatedAttributes: {
+ estimatedResultCount: "cursor.estimatedResultCount"
+ },
+
+ // label: String
+ // The default attribute which acts as a label for each item.
+ label: "titleNoFormatting",
+
+ // type: String
+ // The type of search. Valid values are "web", "local", "video", "blogs", "news", "books", "images".
+ // This should not be set directly. Instead use one of the child classes.
+ _type: "web",
+
+ // urlPreventCache: boolean
+ // Sets whether or not to pass preventCache to dojo.io.script.
+ urlPreventCache: true,
+
+
+ // _queryAttrs: Hash
+ // Maps query hash keys to Google query parameters.
+ _queryAttrs: {
+ text: 'q'
+ },
+
+ _assertIsItem: function(/* item */ item){
+ // summary:
+ // This function tests whether the item passed in is indeed an item in the store.
+ // item:
+ // The item to test for being contained by the store.
+ if(!this.isItem(item)){
+ throw new Error("dojox.data.GoogleSearchStore: a function was passed an item argument that was not an item");
+ }
+ },
+
+ _assertIsAttribute: function(/* attribute-name-string */ attribute){
+ // summary:
+ // This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
+ // attribute:
+ // The attribute to test for being contained by the store.
+ if(typeof attribute !== "string"){
+ throw new Error("dojox.data.GoogleSearchStore: a function was passed an attribute argument that was not an attribute name string");
+ }
+ },
+
+ getFeatures: function(){
+ // summary:
+ // See dojo.data.api.Read.getFeatures()
+ return {
+ 'dojo.data.api.Read': true
+ };
+ },
+
+ getValue: function(item, attribute, defaultValue){
+ // summary:
+ // See dojo.data.api.Read.getValue()
+ var values = this.getValues(item, attribute);
+ if(values && values.length > 0){
+ return values[0];
+ }
+ return defaultValue;
+ },
+
+ getAttributes: function(item){
+ // summary:
+ // See dojo.data.api.Read.getAttributes()
+ return this._attributes;
+ },
+
+ hasAttribute: function(item, attribute){
+ // summary:
+ // See dojo.data.api.Read.hasAttributes()
+ if(this.getValue(item,attribute)){
+ return true;
+ }
+ return false;
+ },
+
+ isItemLoaded: function(item){
+ // summary:
+ // See dojo.data.api.Read.isItemLoaded()
+ return this.isItem(item);
+ },
+
+ loadItem: function(keywordArgs){
+ // summary:
+ // See dojo.data.api.Read.loadItem()
+ },
+
+ getLabel: function(item){
+ // summary:
+ // See dojo.data.api.Read.getLabel()
+ return this.getValue(item,this.label);
+ },
+
+ getLabelAttributes: function(item){
+ // summary:
+ // See dojo.data.api.Read.getLabelAttributes()
+ return [this.label];
+ },
+
+ containsValue: function(item, attribute, value){
+ // summary:
+ // See dojo.data.api.Read.containsValue()
+ var values = this.getValues(item,attribute);
+ for(var i = 0; i < values.length; i++){
+ if(values[i] === value){
+ return true;
+ }
+ }
+ return false;
+ },
+
+ getValues: function(item, attribute){
+ // summary:
+ // See dojo.data.api.Read.getValue()
+ this._assertIsItem(item);
+ this._assertIsAttribute(attribute);
+ var val = item[attribute];
+ if(dojo.isArray(val)) {
+ return val;
+ }else if(val !== undefined){
+ return [val];
+ }else{
+ return [];
+ }
+ },
+
+ isItem: function(item){
+ // summary:
+ // See dojo.data.api.Read.isItem()
+ if(item && item[this._storeRef] === this){
+ return true;
+ }
+ return false;
+ },
+
+ close: function(request){
+ // summary:
+ // See dojo.data.api.Read.close()
+ },
+
+ _format: function(item, name){
+ return item;//base implementation does not format any items
+ },
+
+ fetch: function(request){
+ // summary:
+ // Fetch Google search items that match to a query
+ // request:
+ // A request object
+ // fetchHandler:
+ // A function to call for fetched items
+ // errorHandler:
+ // A function to call on error
+ request = request || {};
+
+ var scope = request.scope || dojo.global;
+
+ if(!request.query){
+ if(request.onError){
+ request.onError.call(scope, new Error(this.declaredClass +
+ ": A query must be specified."));
+ return;
+ }
+ }
+ //Make a copy of the request object, in case it is
+ //modified outside the store in the middle of a request
+ var query = {};
+ for(var attr in this._queryAttrs) {
+ query[attr] = request.query[attr];
+ }
+ request = {
+ query: query,
+ onComplete: request.onComplete,
+ onError: request.onError,
+ onItem: request.onItem,
+ onBegin: request.onBegin,
+ start: request.start,
+ count: request.count
+ };
+
+ //Google's web api will only return a max of 8 results per page.
+ var pageSize = 8;
+
+ //Generate a unique function to be called back
+ var callbackFn = "GoogleSearchStoreCallback_" + this._id + "_" + (++this._requestCount);
+
+ //Build up the content to send the request for.
+ //rsz is the result size, "large" gives 8 results each time
+ var content = this._createContent(query, callbackFn, request);
+
+ var firstRequest;
+
+ if(typeof(request.start) === "undefined" || request.start === null){
+ request.start = 0;
+ }
+
+ if(!request.count){
+ request.count = pageSize;
+ }
+ firstRequest = {start: request.start - request.start % pageSize};
+
+ var _this = this;
+ var searchUrl = this._googleUrl + this._type;
+
+ var getArgs = {
+ url: searchUrl,
+ preventCache: this.urlPreventCache,
+ content: content
+ };
+
+ var items = [];
+ var successfulReq = 0;
+ var finished = false;
+ var lastOnItem = request.start -1;
+ var numRequests = 0;
+ var scriptIds = [];
+
+ // Performs the remote request.
+ function doRequest(req){
+ //Record how many requests have been made.
+ numRequests ++;
+ getArgs.content.context = getArgs.content.start = req.start;
+
+ var deferred = dojo.io.script.get(getArgs);
+ scriptIds.push(deferred.ioArgs.id);
+
+ //We only set up the errback, because the callback isn't ever really used because we have
+ //to link to the jsonp callback function....
+ deferred.addErrback(function(error){
+ if(request.onError){
+ request.onError.call(scope, error, request);
+ }
+ });
+ }
+
+ // Function to handle returned data.
+ var myHandler = function(start, data){
+ if (scriptIds.length > 0) {
+ // Delete the script node that was created.
+ dojo.query("#" + scriptIds.splice(0,1)).forEach(dojo.destroy);
+ }
+ if(finished){return;}
+
+ var results = _this._getItems(data);
+ var cursor = data ? data['cursor']: null;
+
+ if(results){
+ //Process the results, adding the store reference to them
+ for(var i = 0; i < results.length && i + start < request.count + request.start; i++) {
+ _this._processItem(results[i], data);
+ items[i + start] = results[i];
+ }
+ successfulReq ++;
+ if(successfulReq == 1){
+ // After the first request, we know how many results exist.
+ // So perform any follow up requests to retrieve more data.
+ var pages = cursor ? cursor.pages : null;
+ var firstStart = pages ? Number(pages[pages.length - 1].start) : 0;
+
+ //Call the onBegin method if it exists
+ if (request.onBegin){
+ var est = cursor ? cursor.estimatedResultCount : results.length;
+ var total = est ? Math.min(est, firstStart + results.length) : firstStart + results.length;
+ request.onBegin.call(scope, total, request);
+ }
+
+ // Request the next pages.
+ var nextPage = (request.start - request.start % pageSize) + pageSize;
+ var page = 1;
+ while(pages){
+ if(!pages[page] || Number(pages[page].start) >= request.start + request.count){
+ break;
+ }
+ if(Number(pages[page].start) >= nextPage) {
+ doRequest({start: pages[page].start});
+ }
+ page++;
+ }
+ }
+
+ // Call the onItem function on all retrieved items.
+ if(request.onItem && items[lastOnItem + 1]){
+ do{
+ lastOnItem++;
+ request.onItem.call(scope, items[lastOnItem], request);
+ }while(items[lastOnItem + 1] && lastOnItem < request.start + request.count);
+ }
+
+ //If this is the last request, call final fetch handler.
+ if(successfulReq == numRequests){
+ //Process the items...
+ finished = true;
+ //Clean up the function, it should never be called again
+ dojo.global[callbackFn] = null;
+ if(request.onItem){
+ request.onComplete.call(scope, null, request);
+ }else{
+ items = items.slice(request.start, request.start + request.count);
+ request.onComplete.call(scope, items, request);
+ }
+
+ }
+ }
+ };
+
+ var callbacks = [];
+ var lastCallback = firstRequest.start - 1;
+
+ // Attach a callback function to the global namespace, where Google can call it.
+ dojo.global[callbackFn] = function(start, data, responseCode, errorMsg){
+ try {
+ if(responseCode != 200){
+ if(request.onError){
+ request.onError.call(scope, new Error("Response from Google was: " + responseCode), request);
+ }
+ dojo.global[callbackFn] = function(){};//an error occurred, do not return anything else.
+ return;
+ }
+
+ if(start == lastCallback + 1){
+ myHandler(Number(start), data);
+ lastCallback += pageSize;
+
+ //make sure that the callbacks happen in the correct sequence
+ if(callbacks.length > 0){
+ callbacks.sort(_this._getSort());
+ //In case the requsts do not come back in order, sort the returned results.
+ while(callbacks.length > 0 && callbacks[0].start == lastCallback + 1){
+ myHandler(Number(callbacks[0].start), callbacks[0].data);
+ callbacks.splice(0,1);
+ lastCallback += pageSize;
+ }
+ }
+ }else{
+ callbacks.push({start:start, data: data});
+ }
+ } catch (e) {
+ request.onError.call(scope, e, request);
+ }
+ };
+
+ // Perform the first request. When this has finished
+ // we will have a list of pages, which can then be
+ // gone through
+ doRequest(firstRequest);
+ },
+
+ _getSort: function() {
+ return function(a,b){
+ if(a.start < b.start){return -1;}
+ if(b.start < a.start){return 1;}
+ return 0;
+ };
+ },
+
+ _processItem: function(item, data) {
+ item[this._storeRef] = this;
+ // Copy aggregated attributes from query results to the item.
+ for(var attribute in this._aggregatedAttributes) {
+ item[attribute] = dojo.getObject(this._aggregatedAttributes[attribute], false, data);
+ }
+ },
+
+ _getItems: function(data){
+ return data['results'] || data;
+ },
+
+ _createContent: function(query, callback, request){
+ var content = {
+ v: "1.0",
+ rsz: "large",
+ callback: callback,
+ key: this._key,
+ hl: this._lang
+ };
+ for(var attr in this._queryAttrs) {
+ content[this._queryAttrs[attr]] = query[attr];
+ }
+ return content;
+ }
+});
+
+dojo.declare("dojox.data.GoogleWebSearchStore", dojox.data.GoogleSearchStore,{
+ // Summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The page title in HTML format.</li>
+ // <li>titleNoFormatting - The page title in plain text</li>
+ // <li>content - A snippet of information about the page</li>
+ // <li>url - The URL for the item</li>
+ // <li>unescapedUrl - The URL for the item, with URL escaping. This is often more readable</li>
+ // <li>visibleUrl - The URL with no protocol specified.</li>
+ // <li>cacheUrl - The URL to the copy of the document cached by Google</li>
+ // <li>estimatedResultCount - (aggregated per-query) estimated number of results</li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+});
+
+dojo.declare("dojox.data.GoogleBlogSearchStore", dojox.data.GoogleSearchStore,{
+ // Summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The blog post title in HTML format.</li>
+ // <li>titleNoFormatting - The blog post title in plain text</li>
+ // <li>content - A snippet of information about the blog post</li>
+ // <li>blogUrl - The URL for the blog</li>
+ // <li>postUrl - The URL for the a single blog post</li>
+ // <li>visibleUrl - The URL with no protocol specified.
+ // <li>cacheUrl - The URL to the copy of the document cached by Google
+ // <li>author - The author of the blog post</li>
+ // <li>publishedDate - The published date, in RFC-822 format</li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+ _type: "blogs",
+ _attributes: ["blogUrl", "postUrl", "title", "titleNoFormatting", "content",
+ "author", "publishedDate"],
+ _aggregatedAttributes: { }
+});
+
+
+dojo.declare("dojox.data.GoogleLocalSearchStore", dojox.data.GoogleSearchStore,{
+ // summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The blog post title in HTML format.</li>
+ // <li>titleNoFormatting - The blog post title in plain text</li>
+ // <li>content - A snippet of information about the blog post</li>
+ // <li>url - The URL for the item</li>
+ // <li>lat - The latitude.</li>
+ // <li>lng - The longtitude.</li>
+ // <li>streetAddress - The street address</li>
+ // <li>city - The city</li>
+ // <li>region - The region</li>
+ // <li>country - The country</li>
+ // <li>phoneNumbers - Phone numbers associated with this address. Can be one or more.</li>
+ // <li>ddUrl - A URL that can be used to provide driving directions from the center of the search results to this search results</li>
+ // <li>ddUrlToHere - A URL that can be used to provide driving directions from this search result to a user specified location</li>
+ // <li>staticMapUrl - The published date, in RFC-822 format</li>
+ // <li>viewport - Recommended viewport for the query results (same for all results in a query)
+ // <ul>
+ // <li>center - contains lat, lng properties</li>
+ // <li>span - lat, lng properties for the viewport span</li>
+ // <li>ne, sw - lat, lng properties for the viewport corners<li>
+ // </ul>
+ // </li>
+ // </ul>
+ // The query accepts the following parameters:
+ // <ul>
+ // <li>text - The string to search for</li>
+ // <li>centerLatLong - Comma-separated lat & long for the center of the search (e.g. "48.8565,2.3509")</li>
+ // <li>searchSpan - Comma-separated lat & long degrees indicating the size of the desired search area (e.g. "0.065165,0.194149")</li>
+ // </ul>
+ _type: "local",
+ _attributes: ["title", "titleNoFormatting", "url", "lat", "lng", "streetAddress",
+ "city", "region", "country", "phoneNumbers", "ddUrl", "ddUrlToHere",
+ "ddUrlFromHere", "staticMapUrl", "viewport"],
+ _aggregatedAttributes: {
+ viewport: "viewport"
+ },
+ _queryAttrs: {
+ text: 'q',
+ centerLatLong: 'sll',
+ searchSpan: 'sspn'
+ }
+});
+
+dojo.declare("dojox.data.GoogleVideoSearchStore", dojox.data.GoogleSearchStore,{
+ // summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The blog post title in HTML format.</li>
+ // <li>titleNoFormatting - The blog post title in plain text</li>
+ // <li>content - A snippet of information about the blog post</li>
+ // <li>url - The URL for the item</li>
+ // <li>published - The published date, in RFC-822 format.</li>
+ // <li>publisher - The name of the publisher.</li>
+ // <li>duration - The approximate duration, in seconds, of the video.</li>
+ // <li>tbWidth - The width in pixels of the video.</li>
+ // <li>tbHeight - The height in pixels of the video</li>
+ // <li>tbUrl - The URL to a thumbnail representation of the video.</li>
+ // <li>playUrl - If present, supplies the url of the flash version of the video that can be played inline on your page. To play this video simply create and <embed> element on your page using this value as the src attribute and using application/x-shockwave-flash as the type attribute. If you want the video to play right away, make sure to append &autoPlay=true to the url..</li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+ _type: "video",
+ _attributes: ["title", "titleNoFormatting", "content", "url", "published", "publisher",
+ "duration", "tbWidth", "tbHeight", "tbUrl", "playUrl"],
+ _aggregatedAttributes: { }
+});
+
+dojo.declare("dojox.data.GoogleNewsSearchStore", dojox.data.GoogleSearchStore,{
+ // summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The news story title in HTML format.</li>
+ // <li>titleNoFormatting - The news story title in plain text</li>
+ // <li>content - A snippet of information about the news story</li>
+ // <li>url - The URL for the item</li>
+ // <li>unescapedUrl - The URL for the item, with URL escaping. This is often more readable</li>
+ // <li>publisher - The name of the publisher</li>
+ // <li>clusterUrl - A URL pointing to a page listing related storied.</li>
+ // <li>location - The location of the news story.</li>
+ // <li>publishedDate - The date of publication, in RFC-822 format.</li>
+ // <li>relatedStories - An optional array of objects specifying related stories.
+ // Each object has the following subset of properties:
+ // "title", "titleNoFormatting", "url", "unescapedUrl", "publisher", "location", "publishedDate".
+ // </li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+ _type: "news",
+ _attributes: ["title", "titleNoFormatting", "content", "url", "unescapedUrl", "publisher",
+ "clusterUrl", "location", "publishedDate", "relatedStories" ],
+ _aggregatedAttributes: { }
+});
+
+dojo.declare("dojox.data.GoogleBookSearchStore", dojox.data.GoogleSearchStore,{
+ // summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The book title in HTML format.</li>
+ // <li>titleNoFormatting - The book title in plain text</li>
+ // <li>authors - An array of authors</li>
+ // <li>url - The URL for the item</li>
+ // <li>unescapedUrl - The URL for the item, with URL escaping. This is often more readable</li>
+ // <li>bookId - An identifier for the book, usually an ISBN.</li>
+ // <li>pageCount - The number of pages in the book.</li>
+ // <li>publishedYear - The year of publication.</li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+ _type: "books",
+ _attributes: ["title", "titleNoFormatting", "authors", "url", "unescapedUrl", "bookId",
+ "pageCount", "publishedYear"],
+ _aggregatedAttributes: { }
+});
+
+dojo.declare("dojox.data.GoogleImageSearchStore", dojox.data.GoogleSearchStore,{
+ // summary:
+ // A data store for retrieving search results from Google.
+ // The following attributes are supported on each item:
+ // <ul>
+ // <li>title - The image title in HTML format.</li>
+ // <li>titleNoFormatting - The image title in plain text</li>
+ // <li>url - The URL for the image</li>
+ // <li>unescapedUrl - The URL for the image, with URL escaping. This is often more readable</li>
+ // <li>tbUrl - The URL for the image thumbnail</li>
+ // <li>visibleUrl - A shortened version of the URL associated with the result, stripped of a protocol and path</li>
+ // <li>originalContextUrl - The URL of the page containing the image.</li>
+ // <li>width - The width of the image in pixels.</li>
+ // <li>height - The height of the image in pixels.</li>
+ // <li>tbWidth - The width of the image thumbnail in pixels.</li>
+ // <li>tbHeight - The height of the image thumbnail in pixels.</li>
+ // <li>content - A snippet of information about the image, in HTML format</li>
+ // <li>contentNoFormatting - A snippet of information about the image, in plain text</li>
+ // </ul>
+ // The query accepts one parameter: text - The string to search for
+ _type: "images",
+ _attributes: ["title", "titleNoFormatting", "visibleUrl", "url", "unescapedUrl",
+ "originalContextUrl", "width", "height", "tbWidth", "tbHeight",
+ "tbUrl", "content", "contentNoFormatting"],
+ _aggregatedAttributes: { }
+});
+
+}
+
+}};});
|