@push.rocks/websetup/dist_bundle/bundle.js

setup basic page properties

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// node_modules/.pnpm/@pushrocks+smartpromise@4.0.2/node_modules/@pushrocks/smartpromise/dist_ts/index.js
var dist_ts_exports = {};
__export(dist_ts_exports, {
  CumulativeDeferred: () => CumulativeDeferred,
  Deferred: () => Deferred,
  cumulativeDefer: () => cumulativeDefer,
  defer: () => defer,
  getFirstTrueOrFalse: () => getFirstTrueOrFalse,
  map: () => map,
  rejectedPromise: () => rejectedPromise,
  resolvedPromise: () => resolvedPromise,
  timeoutAndContinue: () => timeoutAndContinue,
  timeoutWrap: () => timeoutWrap
});

// node_modules/.pnpm/@pushrocks+smartpromise@4.0.2/node_modules/@pushrocks/smartpromise/dist_ts/smartpromise.classes.deferred.js
var Deferred = class {
  claim() {
    if (this.claimed) {
      throw new Error("Deferred already claimed");
    }
    this.claimed = true;
  }
  get duration() {
    if (this.stoppedAt) {
      return this.stoppedAt - this.startedAt;
    } else {
      return Date.now() - this.startedAt;
    }
  }
  constructor() {
    this.claimed = false;
    this.promise = new Promise((resolve, reject) => {
      this.resolve = (valueArg) => {
        this.status = "fulfilled";
        this.stoppedAt = Date.now();
        resolve(valueArg);
      };
      this.reject = (reason) => {
        this.status = "rejected";
        this.stoppedAt = Date.now();
        reject(reason);
      };
      this.startedAt = Date.now();
      this.status = "pending";
    });
  }
};
var defer = () => {
  return new Deferred();
};

// node_modules/.pnpm/@pushrocks+smartpromise@4.0.2/node_modules/@pushrocks/smartpromise/dist_ts/smartpromise.classes.cumulativedeferred.js
var CumulativeDeferred = class {
  constructor() {
    this.accumulatedPromises = [];
    this.deferred = defer();
    this.promise = this.deferred.promise;
    setTimeout(async () => {
      while (this.accumulatedPromises.length > 0) {
        const poppedPromise = this.accumulatedPromises.shift();
        await poppedPromise;
      }
      this.deferred.resolve();
    }, 0);
  }
  addPromise(promiseArg) {
    this.accumulatedPromises.push(promiseArg);
  }
};
var cumulativeDefer = () => {
  return new CumulativeDeferred();
};

// node_modules/.pnpm/@pushrocks+smartpromise@4.0.2/node_modules/@pushrocks/smartpromise/dist_ts/index.js
var resolvedPromise = (value) => {
  return Promise.resolve(value);
};
var rejectedPromise = (err) => {
  return Promise.reject(err);
};
var map = async (inputArg, functionArg) => {
  const promiseArray = [];
  const resultArray = [];
  for (const item of inputArg) {
    const promise = functionArg(item);
    promiseArray.push(promise);
    promise.then((x) => {
      resultArray.push(x);
    });
  }
  await Promise.all(promiseArray);
  return resultArray;
};
var timeoutWrap = async (promiseArg, timeoutInMsArg, rejectArg = true) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (rejectArg) {
        reject(new Error("timeout"));
      } else {
        resolve(null);
      }
    }, timeoutInMsArg);
    promiseArg.then(resolve, reject);
  });
};
var timeoutAndContinue = async (promiseArg, timeoutInMsArg = 6e4) => {
  return timeoutWrap(promiseArg, timeoutInMsArg, false);
};
var getFirstTrueOrFalse = async (promisesArg) => {
  const done = defer();
  for (const promiseArg of promisesArg) {
    promiseArg.then((resultArg) => {
      if (resultArg === true) {
        done.resolve(true);
      }
    });
  }
  Promise.all(promisesArg).then(() => {
    done.resolve(false);
  });
  return done.promise;
};

// ts/websetup.classes.tag.ts
var Tag = class {
  appendToDom() {
    if (!this.elementRef.parentElement && !this.elementRef.parentNode) {
      document.getElementsByTagName("head")[0].appendChild(this.elementRef);
    }
  }
  removeFromDom() {
    if (this.elementRef.parentElement) {
      this.elementRef.parentElement.removeChild(this.elementRef);
    } else if (this.elementRef.parentNode) {
      this.elementRef.parentNode.removeChild(this.elementRef);
    }
  }
};

// ts/websetup.classes.tag.jsonldtag.ts
var JsonLdTag = class extends Tag {
  static createCompanyJsonLd(companyDataArg) {
    const companyLd = {
      "@context": "https://schema.org",
      "@type": "Corporation",
      name: companyDataArg.name,
      alternateName: companyDataArg.name.replace(" GmbH", ""),
      url: companyDataArg.contact.website,
      logo: companyDataArg.contact.logoUrl,
      contactPoint: {
        "@type": "ContactPoint",
        telephone: companyDataArg.contact.phone,
        contactType: "customer service",
        areaServed: "DE",
        availableLanguage: ["en", "German"]
      },
      sameAs: []
    };
    if (companyDataArg.contact.facebookUrl) {
      companyLd.sameAs.push(companyDataArg.contact.facebookUrl);
    }
    if (companyDataArg.contact.twitterUrl) {
      companyLd.sameAs.push(companyDataArg.contact.twitterUrl);
    }
    const ldTag = new JsonLdTag(companyLd);
    return ldTag;
  }
  static createNewsArticleJsonLd(newsArticleArg) {
    const newsArticleLd = {
      "@context": "https://schema.org",
      "@type": "NewsArticle",
      mainEntityOfPage: {
        "@type": "WebPage",
        "@id": window.location.href
      },
      headline: "Article headline",
      image: [newsArticleArg.featuredImageUrl],
      datePublished: new Date(newsArticleArg.timestamp).toISOString(),
      dateModified: new Date(newsArticleArg.timestamp).toISOString(),
      author: {
        "@type": "Person",
        name: `${newsArticleArg.author.firstName} ${newsArticleArg.author.surName}`
      },
      publisher: {
        "@type": "Organization",
        name: newsArticleArg.author.surName,
        logo: {
          "@type": "ImageObject",
          url: newsArticleArg.author.surName
        }
      },
      description: newsArticleArg.author.firstName
    };
    const ldTag = new JsonLdTag(newsArticleLd);
    return ldTag;
  }
  static createProductJsonLd(productArg, publisherArg) {
    const productLd = {
      "@context": "https://schema.org",
      "@type": "SoftwareApplication",
      name: productArg.name,
      description: productArg.description,
      operatingSystem: productArg.os,
      applicationCategory: productArg.category,
      offers: {
        "@type": "Offer",
        name: "User-based Plan",
        priceSpecification: {
          "@type": "PropertyValueSpecification",
          valueName: "Number of Users",
          valueRequired: true,
          price: "4.99",
          priceCurrency: "EUR"
        }
      },
      publisher: this.createCompanyJsonLd(publisherArg).elementRef.textContent,
      screenshot: "https://www.social.io/screenshot.png",
      url: "https://www.social.io/"
    };
    const ldTag = new JsonLdTag(productLd);
    return ldTag;
  }
  constructor(ldObjectArg) {
    super();
    const jsonLdElement = document.createElement("script");
    jsonLdElement.type = "application/ld+json";
    jsonLdElement.text = JSON.stringify(ldObjectArg);
    this.elementRef = jsonLdElement;
  }
};

// ts/websetup.classes.tag.opengraphtag.ts
var OpengraphTag = class extends Tag {
  static createNewsArticleOgTags(newsArticleArg) {
    const tagArray = [];
    tagArray.push(new OpengraphTag("og:url", newsArticleArg.url));
    tagArray.push(new OpengraphTag("og:title", newsArticleArg.title));
    tagArray.push(new OpengraphTag("og:description", newsArticleArg.content));
    tagArray.push(new OpengraphTag("og:image", newsArticleArg.featuredImageUrl));
    return tagArray;
  }
  static createProductOgTags(productArg) {
    const tagArray = [];
    tagArray.push(new OpengraphTag("og:url", globalThis.location.href));
    tagArray.push(new OpengraphTag("og:title", `${productArg.name} - ${productArg.slogan}`));
    tagArray.push(new OpengraphTag("og:site_name", productArg.name));
    tagArray.push(new OpengraphTag("og:description", productArg.description));
    tagArray.push(new OpengraphTag("og:image", productArg.logoLink));
    return tagArray;
  }
  constructor(propertyNameArg, contentArg) {
    super();
    const openGraphElement = document.createElement("meta");
    openGraphElement.setAttribute("property", propertyNameArg);
    openGraphElement.content = contentArg;
    this.elementRef = openGraphElement;
  }
};

// ts/websetup.classes.taglevel.ts
var TagLevel = class {
  constructor(tagManagerRefArg, levelType) {
    this.tags = [];
    this.state = "disabled";
    this.tagManagerRef = tagManagerRefArg;
  }
  set title(titleArg) {
    this.titleStore = titleArg;
    if (this.state === "enabled") {
      document.title = this.titleStore;
    }
  }
  get title() {
    return this.titleStore;
  }
  addTag(tagArg) {
    if (tagArg instanceof Array) {
      for (const tagArg2 of tagArg) {
        this.addTag(tagArg2);
      }
    } else {
      this.tags.push(tagArg);
      if (this.state === "enabled") {
        tagArg.appendToDom();
      }
    }
  }
  async addCompanyInfo(companyDataArg) {
    this.addTag(JsonLdTag.createCompanyJsonLd(companyDataArg));
    this.addTag(new OpengraphTag("og:type", "business.business"));
    this.addTag(new OpengraphTag("og:title", companyDataArg.name));
    this.addTag(new OpengraphTag("og:url", companyDataArg.contact.website));
    this.addTag(new OpengraphTag("og:image", companyDataArg.contact.logoUrl));
    this.addTag(
      new OpengraphTag(
        "business:contact_data:street_address",
        `${companyDataArg.contact.address.streetName} ${companyDataArg.contact.address.houseNumber}`
      )
    );
    this.addTag(
      new OpengraphTag("business:contact_data:locality", companyDataArg.contact.address.postalCode)
    );
    this.addTag(
      new OpengraphTag("business:contact_data:region", companyDataArg.contact.address.city)
    );
    this.addTag(
      new OpengraphTag(
        "business:contact_data:postal_code",
        companyDataArg.contact.address.postalCode
      )
    );
    this.addTag(
      new OpengraphTag("business:contact_data:country_name", companyDataArg.contact.address.country)
    );
  }
  addNewsArticleInfo(articleArg) {
    this.addTag(JsonLdTag.createNewsArticleJsonLd(articleArg));
    this.addTag(OpengraphTag.createNewsArticleOgTags(articleArg));
  }
  addProductInfo(productArg, companyArg) {
    this.addTag(JsonLdTag.createProductJsonLd(productArg, companyArg));
    this.addTag(OpengraphTag.createProductOgTags(productArg));
  }
  async enable() {
    if (this.title) {
      document.title = this.title;
    }
    for (const tagArg of this.tags) {
      tagArg.appendToDom();
    }
    this.state = "enabled";
  }
  async disable() {
    for (const tagArg of this.tags) {
      tagArg.removeFromDom();
    }
    this.state = "disabled";
  }
};

// ts/websetup.classes.tag.metatag.ts
var MetaTag = class extends Tag {
  constructor(metaNameArg, contentArg) {
    super();
    const metaElement = document.createElement("meta");
    metaElement.name = metaNameArg;
    metaElement.content = contentArg;
    this.elementRef = metaElement;
  }
};

// ts/websetup.classes.tagmanager.ts
var TagManager2 = class {
  constructor() {
    this.globalLevel = new TagLevel(this, "global");
    this.baseLevel = new TagLevel(this, "base");
  }
  async setup(metaObjectArg) {
    this.globalLevel.addTag(new MetaTag("google", "notranslate"));
    this.globalLevel.addTag(new MetaTag("revisit-after", "1 days"));
    if (metaObjectArg.twitterHandle) {
      this.globalLevel.addTag(new MetaTag("twitter:card", "summary_large_image"));
      this.globalLevel.addTag(new MetaTag("twitter:site", metaObjectArg.twitterHandle));
      this.globalLevel.addTag(new MetaTag("twitter:creator", metaObjectArg.twitterHandle));
    }
    this.baseLevel.title = metaObjectArg.title;
    if (metaObjectArg.description) {
      this.baseLevel.addTag(new MetaTag("description", metaObjectArg.description));
    }
    if (metaObjectArg.canonicalDomain) {
      this.baseLevel.addTag(new MetaTag("canonical", metaObjectArg.canonicalDomain));
    }
    switch (true) {
      case (metaObjectArg.ldCompany && !metaObjectArg.ldProduct):
        this.baseLevel.addCompanyInfo(metaObjectArg.ldCompany);
        break;
      case !!metaObjectArg.ldProduct:
        this.baseLevel.addProductInfo(metaObjectArg.ldProduct, metaObjectArg.ldCompany);
        break;
    }
    await this.globalLevel.enable();
    this.activeLevel = this.baseLevel;
    await this.activeLevel.enable();
  }
  async setSubPageLevel(metaObjectArg) {
    const subPageLevel = new TagLevel(this, "subpage");
    subPageLevel.title = metaObjectArg.title;
    if (metaObjectArg.description) {
      subPageLevel.addTag(new MetaTag("description", metaObjectArg.description));
    }
    await this.activeLevel.disable();
    this.activeLevel = subPageLevel;
    await this.activeLevel.enable();
    return subPageLevel;
  }
  async revertToBaseLevel() {
    if (this.activeLevel !== this.baseLevel) {
      await this.activeLevel.disable();
      this.activeLevel = this.baseLevel;
      await this.activeLevel.enable();
    }
  }
};

// ts/websetup.classes.websetup.ts
var WebSetup = class {
  constructor(optionsArg) {
    this.tagManager = new TagManager2();
    this.readyDeferred = dist_ts_exports.defer();
    this.readyForSmartssrDeferred = dist_ts_exports.defer();
    this.readyPromise = this.readyDeferred.promise;
    this.readyForSmartssrPromise = this.readyForSmartssrDeferred.promise;
    this.options = optionsArg;
    this.setup().then(() => {
      this.readyDeferred.resolve();
      if (!this.options.smartssrWaitForReadySignal) {
        this.readyForSmartssrDeferred.resolve();
      }
    });
  }
  async setup(optionsArg) {
    if (optionsArg) {
      this.options = optionsArg;
    }
    await this.tagManager.setup(this.options.metaObject);
  }
  revertToBaseLevel() {
    this.tagManager.revertToBaseLevel();
  }
  async setSubLevel(metaObjectArg) {
    const subLevel = await this.tagManager.setSubPageLevel(metaObjectArg);
    return subLevel;
  }
  flashTitle(flashTextArg) {
  }
  informReadyForSmartssr() {
    if (!this.options.smartssrWaitForReadySignal) {
      console.error(
        `You have not indicated that you inform smartssr by a dedicated signal! Please consider doing so!`
      );
    }
    this.readyForSmartssrDeferred.resolve();
  }
};

// ts/websetup.classes.title.ts
var Title = class {
};
export {
  JsonLdTag,
  MetaTag,
  OpengraphTag,
  Title,
  WebSetup
};
//# sourceMappingURL=bundle.js.map