diff --git a/packages/web-app-files/src/components/SideBar/Shares/FileLinks.vue b/packages/web-app-files/src/components/SideBar/Shares/FileLinks.vue
index 2644cdc391c..fd396be7b1f 100644
--- a/packages/web-app-files/src/components/SideBar/Shares/FileLinks.vue
+++ b/packages/web-app-files/src/components/SideBar/Shares/FileLinks.vue
@@ -15,7 +15,7 @@
       <create-quick-link
         v-else-if="canCreateLinks"
         :expiration-rules="expirationRules"
-        @create-public-link="checkLinkToCreate"
+        @create-public-link="addNewLink"
       />
       <details-and-edit
         v-if="quicklink"
@@ -124,8 +124,9 @@ import {
   useCapabilityFilesSharingPublicPasswordEnforcedFor,
   useAbility,
   usePasswordPolicyService,
-  getDefaultLinkPermissions,
-  useExpirationRules
+  useExpirationRules,
+  useDefaultLinkPermissions,
+  useCreateLink
 } from '@ownclouders/web-pkg'
 import { shareViaLinkHelp, shareViaIndirectLinkHelp } from '../../../helpers/contextualHelpers'
 import {
@@ -137,7 +138,6 @@ import {
   Share,
   SharePermissions
 } from '@ownclouders/web-client/src/helpers/share'
-import { showQuickLinkPasswordModal } from '@ownclouders/web-pkg'
 import DetailsAndEdit from './Links/DetailsAndEdit.vue'
 import NameAndCopy from './Links/NameAndCopy.vue'
 import CreateQuickLink from './Links/CreateQuickLink.vue'
@@ -151,6 +151,7 @@ import {
 import { isLocationSharesActive } from '@ownclouders/web-pkg'
 import { useShares } from 'web-app-files/src/composables'
 import { configurationManager } from '@ownclouders/web-pkg'
+import { useGettext } from 'vue3-gettext'
 
 export default defineComponent({
   name: 'FileLinks',
@@ -161,11 +162,15 @@ export default defineComponent({
   },
   setup() {
     const store = useStore()
+    const { $gettext } = useGettext()
     const ability = useAbility()
     const { can } = ability
     const { expirationRules } = useExpirationRules()
     const passwordPolicyService = usePasswordPolicyService()
     const hasResharing = useCapabilityFilesSharingResharing()
+    const hasShareJail = useCapabilityShareJailEnabled()
+    const { defaultLinkPermissions } = useDefaultLinkPermissions()
+    const { createLink } = useCreateLink()
 
     const space = inject<Ref<SpaceResource>>('space')
     const resource = inject<Ref<Resource>>('resource')
@@ -221,6 +226,36 @@ export default defineComponent({
       )
     }
 
+    const showQuickLinkPasswordModal = (params = {}) => {
+      const modal = {
+        variation: 'passive',
+        title: $gettext('Set password'),
+        cancelText: $gettext('Cancel'),
+        confirmText: $gettext('Set'),
+        hasInput: true,
+        inputDescription: $gettext('Passwords for links are required.'),
+        inputPasswordPolicy: passwordPolicyService.getPolicy(),
+        inputGeneratePasswordMethod: () => passwordPolicyService.generatePassword(),
+        inputLabel: $gettext('Password'),
+        inputType: 'password',
+        onInput: () => store.dispatch('setModalInputErrorMessage', ''),
+        onPasswordChallengeCompleted: () => store.dispatch('setModalConfirmButtonDisabled', false),
+        onPasswordChallengeFailed: () => store.dispatch('setModalConfirmButtonDisabled', true),
+        onCancel: () => store.dispatch('hideModal'),
+        onConfirm: async (newPassword: string) => {
+          await createLink({
+            resource: unref(resource),
+            space: unref(space),
+            ...params,
+            password: newPassword
+          })
+          return store.dispatch('hideModal')
+        }
+      }
+
+      return store.dispatch('createModal', modal)
+    }
+
     return {
       $store: store,
       ability,
@@ -228,7 +263,7 @@ export default defineComponent({
       resource,
       incomingParentShare: inject<Share>('incomingParentShare'),
       hasSpaces: useCapabilitySpacesEnabled(),
-      hasShareJail: useCapabilityShareJailEnabled(),
+      hasShareJail,
       hasPublicLinkEditing: useCapabilityFilesSharingPublicCanEdit(),
       hasPublicLinkContribute: useCapabilityFilesSharingPublicCanContribute(),
       hasPublicLinkAliasSupport: useCapabilityFilesSharingPublicAlias(),
@@ -241,10 +276,12 @@ export default defineComponent({
       canCreatePublicLinks,
       canDeleteReadOnlyPublicLinkPassword,
       configurationManager,
-      passwordPolicyService,
       canCreateLinks,
       canEditLink,
-      expirationRules
+      expirationRules,
+      createLink,
+      showQuickLinkPasswordModal,
+      defaultLinkPermissions
     }
   },
   computed: {
@@ -380,37 +417,12 @@ export default defineComponent({
       )
     },
 
-    addNewLink() {
-      this.checkLinkToCreate({
-        link: {
-          name: this.$gettext('Link'),
-          permissions: getDefaultLinkPermissions({
-            ability: this.ability,
-            store: this.$store
-          }).toString(),
-          expiration: this.expirationRules.default,
-          password: false
-        }
-      })
-    },
-
-    checkLinkToCreate({ link }) {
-      const paramsToCreate = this.getParamsForLink(link)
-
-      if (this.isPasswordEnforcedFor(link)) {
-        showQuickLinkPasswordModal(
-          {
-            ...this.$language,
-            store: this.$store,
-            passwordPolicyService: this.passwordPolicyService
-          },
-          (newPassword) => {
-            this.createLink({ params: { ...paramsToCreate, password: newPassword } })
-          }
-        )
-      } else {
-        this.createLink({ params: paramsToCreate })
+    addNewLink({ link }) {
+      if (this.isPasswordEnforcedFor({ permissions: this.defaultLinkPermissions })) {
+        return this.showQuickLinkPasswordModal(link)
       }
+
+      return this.createLink({ resource: this.resource, space: this.space, ...link })
     },
 
     checkLinkToUpdate({ link }) {
@@ -424,16 +436,7 @@ export default defineComponent({
       }
 
       if (!link.password && !this.canDeletePublicLinkPassword(link)) {
-        showQuickLinkPasswordModal(
-          {
-            ...this.$language,
-            store: this.$store,
-            passwordPolicyService: this.passwordPolicyService
-          },
-          (newPassword) => {
-            this.updatePublicLink({ params: { ...params, password: newPassword } })
-          }
-        )
+        this.showQuickLinkPasswordModal(params)
       } else {
         this.updatePublicLink({ params })
       }
@@ -490,38 +493,6 @@ export default defineComponent({
       }
     },
 
-    async createLink({ params }) {
-      let path = this.resource.path
-      // sharing a share root from the share jail -> use resource name as path
-      if (this.hasShareJail && path === '/') {
-        path = `/${this.resource.name}`
-      }
-      try {
-        await this.addLink({
-          path,
-          client: this.$client,
-          storageId: this.resource.fileId || this.resource.id,
-          params
-        })
-        this.hideModal()
-        this.showMessage({
-          title: this.$gettext('Link was created successfully')
-        })
-      } catch (e) {
-        console.error(e)
-
-        // Human-readable error message is provided, for example when password is on banned list
-        if (e.statusCode === 400) {
-          return this.setModalInputErrorMessage(this.$gettext(e.message))
-        }
-
-        this.showErrorMessage({
-          title: this.$gettext('Failed to create link'),
-          error: e
-        })
-      }
-    },
-
     async updatePublicLink({ params }) {
       try {
         await this.updateLink({
diff --git a/packages/web-app-files/src/components/SideBar/Shares/Links/CreateQuickLink.vue b/packages/web-app-files/src/components/SideBar/Shares/Links/CreateQuickLink.vue
index b045510bbed..7a15f5cef47 100644
--- a/packages/web-app-files/src/components/SideBar/Shares/Links/CreateQuickLink.vue
+++ b/packages/web-app-files/src/components/SideBar/Shares/Links/CreateQuickLink.vue
@@ -26,14 +26,10 @@
 </template>
 
 <script lang="ts">
-import { defineComponent, PropType } from 'vue'
-import {
-  useAbility,
-  getDefaultLinkPermissions,
-  useStore,
-  ExpirationRules
-} from '@ownclouders/web-pkg'
+import { defineComponent, PropType, unref } from 'vue'
+import { useDefaultLinkPermissions } from '@ownclouders/web-pkg'
 import { useGettext } from 'vue3-gettext'
+import { ExpirationRules } from '@ownclouders/web-pkg'
 
 export default defineComponent({
   name: 'CreateQuickLink',
@@ -45,15 +41,14 @@ export default defineComponent({
   },
   emits: ['createPublicLink'],
   setup(props, { emit }) {
-    const store = useStore()
-    const ability = useAbility()
+    const { defaultLinkPermissions } = useDefaultLinkPermissions()
     const { $gettext } = useGettext()
 
     const createQuickLink = () => {
       const emitData = {
         link: {
           name: $gettext('Link'),
-          permissions: getDefaultLinkPermissions({ ability, store }).toString(),
+          permissions: unref(defaultLinkPermissions).toString(),
           expiration: props.expirationRules.enforced ? props.expirationRules.default : null,
           quicklink: true,
           password: false
diff --git a/packages/web-pkg/src/components/CreateLinkModal.vue b/packages/web-pkg/src/components/CreateLinkModal.vue
index b5b9e778f1c..79220fa6a2d 100644
--- a/packages/web-pkg/src/components/CreateLinkModal.vue
+++ b/packages/web-pkg/src/components/CreateLinkModal.vue
@@ -154,18 +154,20 @@ import {
   useCapabilityFilesSharingPublicCanContribute,
   useCapabilityFilesSharingPublicCanEdit,
   useCapabilityFilesSharingPublicPasswordEnforcedFor,
-  useClientService,
   useLoadingService,
   usePasswordPolicyService,
   useStore,
   useEmbedMode,
-  useExpirationRules
+  useExpirationRules,
+  useDefaultLinkPermissions,
+  useCreateLink
 } from '../composables'
-import { formatRelativeDateFromDateTime, getDefaultLinkPermissions } from '../helpers'
+import { formatRelativeDateFromDateTime } from '../helpers'
 import {
   LinkShareRoles,
   Share,
   ShareRole,
+  SpaceResource,
   linkRoleContributorFolder,
   linkRoleEditorFolder,
   linkRoleInternalFolder,
@@ -177,17 +179,22 @@ import { Resource } from '@ownclouders/web-client'
 export default defineComponent({
   name: 'CreatePublicLinksModal',
   props: {
-    resources: { type: Array as PropType<Resource[]>, required: true }
+    resources: { type: Array as PropType<Resource[]>, required: true },
+    space: { type: Object as PropType<SpaceResource>, default: undefined },
+    isQuickLink: { type: Boolean, default: false },
+    showMessages: { type: Boolean, default: true },
+    callbackFn: { type: Function, default: undefined }
   },
-  setup(props, { expose }) {
+  setup(props) {
     const store = useStore()
     const { $gettext, current: currentLanguage } = useGettext()
-    const clientService = useClientService()
     const loadingService = useLoadingService()
     const ability = useAbility()
     const passwordPolicyService = usePasswordPolicyService()
     const { isEnabled: isEmbedEnabled, postMessage } = useEmbedMode()
     const { expirationRules } = useExpirationRules()
+    const { defaultLinkPermissions } = useDefaultLinkPermissions()
+    const { createLink } = useCreateLink()
 
     const hasPublicLinkEditing = useCapabilityFilesSharingPublicCanEdit()
     const hasPublicLinkContribute = useCapabilityFilesSharingPublicCanContribute()
@@ -202,7 +209,7 @@ export default defineComponent({
 
     const password = reactive({ value: '', error: undefined })
     const selectedRole = ref<ShareRole>(
-      LinkShareRoles.getByBitmask(getDefaultLinkPermissions({ ability, store }), unref(isFolder))
+      LinkShareRoles.getByBitmask(unref(defaultLinkPermissions), unref(isFolder))
     ) as Ref<ShareRole>
     const selectedExpiry = ref<DateTime>()
 
@@ -261,29 +268,16 @@ export default defineComponent({
     const createLinks = () => {
       return loadingService.addTask(() =>
         Promise.allSettled<Share>(
-          props.resources.map((resource) => {
-            const params = {
-              name: $gettext('Link'),
-              expireDate: unref(selectedExpiry),
-              password: unref(password).value,
+          props.resources.map((resource) =>
+            createLink({
+              resource,
+              space: props.space,
+              quicklink: props.isQuickLink,
               permissions: unref(selectedRole).bitmask(false),
-              spaceRef: resource.fileId,
-              storageId: resource.fileId || resource.id
-            }
-
-            let path = resource.path
-            // sharing a share root from the share jail -> use resource name as path
-            if (resource.isReceivedShare() && path === '/') {
-              path = `/${resource.name}`
-            }
-
-            return store.dispatch('Files/addLink', {
-              path: resource.path,
-              client: clientService.owncloudSdk,
-              params,
-              storageId: resource.fileId || resource.id
+              password: unref(password).value,
+              expireDate: unref(selectedExpiry)
             })
-          })
+          )
         )
       )
     }
@@ -304,12 +298,14 @@ export default defineComponent({
         (val): val is PromiseFulfilledResult<Share> => val.status === 'fulfilled'
       )
       if (succeeded.length) {
-        store.dispatch('showMessage', {
-          title:
-            succeeded.length > 1
-              ? $gettext('Links have been created successfully')
-              : $gettext('Link has been created successfully')
-        })
+        if (props.showMessages) {
+          store.dispatch('showMessage', {
+            title:
+              succeeded.length > 1
+                ? $gettext('Links have been created successfully')
+                : $gettext('Link has been created successfully')
+          })
+        }
 
         if (unref(isEmbedEnabled)) {
           postMessage<string[]>(
@@ -323,13 +319,19 @@ export default defineComponent({
       if (failed.length) {
         failed.forEach((error) => {
           console.error(error)
-          store.dispatch('showErrorMessage', {
-            title: $gettext('Some links could not be created'),
-            error
-          })
+          if (props.showMessages) {
+            store.dispatch('showErrorMessage', {
+              title: $gettext('Some links could not be created'),
+              error
+            })
+          }
         })
       }
 
+      if (props.callbackFn) {
+        props.callbackFn(result)
+      }
+
       return store.dispatch('hideModal')
     }
 
diff --git a/packages/web-pkg/src/composables/actions/files/useFileActionsCreateQuicklink.ts b/packages/web-pkg/src/composables/actions/files/useFileActionsCreateQuicklink.ts
index f0a83ce2511..21690eb100f 100644
--- a/packages/web-pkg/src/composables/actions/files/useFileActionsCreateQuicklink.ts
+++ b/packages/web-pkg/src/composables/actions/files/useFileActionsCreateQuicklink.ts
@@ -1,17 +1,23 @@
-import { copyQuicklink } from '../../../helpers/share'
-import { ShareStatus } from '@ownclouders/web-client/src/helpers/share'
-
+import {
+  Share,
+  SharePermissionBit,
+  ShareStatus,
+  ShareTypes,
+  buildShare
+} from '@ownclouders/web-client/src/helpers/share'
 import { isLocationSharesActive } from '../../../router'
-import { computed } from 'vue'
-import { useAbility } from '../../ability'
+import { computed, unref } from 'vue'
 import { useClientService } from '../../clientService'
 import { useRouter } from '../../router'
 import { useStore } from '../../store'
 import { useGettext } from 'vue3-gettext'
 import { Store } from 'vuex'
 import { FileAction, FileActionOptions } from '../types'
-import { usePasswordPolicyService } from '../../passwordPolicyService'
 import { useCanShare } from '../../shares'
+import { useCapabilityFilesSharingPublicPasswordEnforcedFor } from '../../capability'
+import { useCreateLink, useDefaultLinkPermissions } from '../../links'
+import { useClipboard } from '../../clipboard'
+import { CreateLinkModal } from '../../../components'
 
 export const useFileActionsCreateQuickLink = ({
   store
@@ -22,23 +28,76 @@ export const useFileActionsCreateQuickLink = ({
   const router = useRouter()
   const language = useGettext()
   const { $gettext } = language
-  const ability = useAbility()
   const clientService = useClientService()
-  const passwordPolicyService = usePasswordPolicyService()
   const { canShare } = useCanShare()
+  const { defaultLinkPermissions } = useDefaultLinkPermissions()
+  const { copyToClipboard } = useClipboard()
+  const passwordEnforcedCapabilities = useCapabilityFilesSharingPublicPasswordEnforcedFor()
+  const { createLink } = useCreateLink()
+
+  const copyQuickLinkToClipboard = async (url: string) => {
+    try {
+      await copyToClipboard(url)
+      return store.dispatch('showMessage', {
+        title: $gettext('The link has been copied to your clipboard.')
+      })
+    } catch (e) {
+      console.error(e)
+      return store.dispatch('showErrorMessage', {
+        title: $gettext('Copy link failed'),
+        error: e
+      })
+    }
+  }
 
   const handler = async ({ space, resources }: FileActionOptions) => {
     const [resource] = resources
+    try {
+      const linkSharesForResource = await clientService.owncloudSdk.shares.getShares(
+        resource.path,
+        {
+          share_types: ShareTypes?.link?.value?.toString(),
+          include_tags: false
+        }
+      )
+
+      const existingQuickLink = linkSharesForResource
+        .map((share: any) => buildShare(share.shareInfo, null, null))
+        .find((share: Share) => share.quicklink === true)
+
+      if (existingQuickLink) {
+        return copyQuickLinkToClipboard(existingQuickLink.url)
+      }
+    } catch (error) {
+      // no share found
+    }
+
+    const passwordEnforced = unref(passwordEnforcedCapabilities).read_only === true
+    if (passwordEnforced && unref(defaultLinkPermissions) > SharePermissionBit.Internal) {
+      return store.dispatch('createModal', {
+        variation: 'passive',
+        title: $gettext('Create link for "%{resourceName}"', { resourceName: resource.name }),
+        hideActions: true,
+        customComponent: CreateLinkModal,
+        customComponentAttrs: {
+          resources,
+          space,
+          isQuickLink: true,
+          showMessages: false,
+          callbackFn: (result: PromiseSettledResult<Share>[]) => {
+            const link = result.find(
+              (val): val is PromiseFulfilledResult<Share> => val.status === 'fulfilled'
+            )
+            if (link?.value) {
+              return copyQuickLinkToClipboard(link.value.url)
+            }
+          }
+        }
+      })
+    }
 
-    await copyQuicklink({
-      clientService,
-      passwordPolicyService,
-      resource,
-      storageId: space?.id || resource?.fileId || resource?.id,
-      store,
-      language,
-      ability
-    })
+    const link = await createLink({ resource, space, quicklink: true })
+    return copyQuickLinkToClipboard(link.url)
   }
 
   const actions = computed((): FileAction[] => [
diff --git a/packages/web-pkg/src/composables/clipboard/index.ts b/packages/web-pkg/src/composables/clipboard/index.ts
new file mode 100644
index 00000000000..965e2e67278
--- /dev/null
+++ b/packages/web-pkg/src/composables/clipboard/index.ts
@@ -0,0 +1 @@
+export * from './useClipboard'
diff --git a/packages/web-pkg/src/composables/clipboard/useClipboard.ts b/packages/web-pkg/src/composables/clipboard/useClipboard.ts
new file mode 100644
index 00000000000..c46611902b5
--- /dev/null
+++ b/packages/web-pkg/src/composables/clipboard/useClipboard.ts
@@ -0,0 +1,27 @@
+import { useClipboard as _useClipboard } from '@vueuse/core'
+
+export const useClipboard = () => {
+  // doCopy creates the requested link and copies the url to the clipboard,
+  // the copy action uses the clipboard // clipboardItem api to work around the webkit limitations.
+  //
+  // https://developer.apple.com/forums/thread/691873
+  //
+  // if those apis not available (or like in firefox behind dom.events.asyncClipboard.clipboardItem)
+  // it has a fallback to the vue-use implementation.
+  //
+  // https://webkit.org/blog/10855/
+  const copyToClipboard = (quickLinkUrl: string) => {
+    if (typeof ClipboardItem && navigator?.clipboard?.write) {
+      return navigator.clipboard.write([
+        new ClipboardItem({
+          'text/plain': new Blob([quickLinkUrl], { type: 'text/plain' })
+        })
+      ])
+    } else {
+      const { copy } = _useClipboard({ legacy: true })
+      return copy(quickLinkUrl)
+    }
+  }
+
+  return { copyToClipboard }
+}
diff --git a/packages/web-pkg/src/composables/index.ts b/packages/web-pkg/src/composables/index.ts
index 11ca6f457af..d56926cf75e 100644
--- a/packages/web-pkg/src/composables/index.ts
+++ b/packages/web-pkg/src/composables/index.ts
@@ -6,6 +6,7 @@ export * from './authContext'
 export * from './breadcrumbs'
 export * from './capability'
 export * from './clientService'
+export * from './clipboard'
 export * from './configuration'
 export * from './download'
 export * from './driveResolver'
diff --git a/packages/web-pkg/src/composables/links/index.ts b/packages/web-pkg/src/composables/links/index.ts
index 9e447c2a677..f43bee3db5c 100644
--- a/packages/web-pkg/src/composables/links/index.ts
+++ b/packages/web-pkg/src/composables/links/index.ts
@@ -1 +1,3 @@
+export * from './useCreateLink'
+export * from './useDefaultLinkPermissions'
 export * from './useExpirationRules'
diff --git a/packages/web-pkg/src/composables/links/useCreateLink.ts b/packages/web-pkg/src/composables/links/useCreateLink.ts
new file mode 100644
index 00000000000..fb093feb00f
--- /dev/null
+++ b/packages/web-pkg/src/composables/links/useCreateLink.ts
@@ -0,0 +1,77 @@
+import { unref } from 'vue'
+import { useStore } from '../store'
+import { useGettext } from 'vue3-gettext'
+import { useDefaultLinkPermissions } from './useDefaultLinkPermissions'
+import {
+  Resource,
+  Share,
+  SpaceResource,
+  isProjectSpaceResource
+} from '@ownclouders/web-client/src/helpers'
+import { useExpirationRules } from './useExpirationRules'
+import { useClientService } from '../clientService'
+
+export const useCreateLink = () => {
+  const store = useStore()
+  const { $gettext } = useGettext()
+  const clientService = useClientService()
+  const { defaultLinkPermissions } = useDefaultLinkPermissions()
+  const { expirationRules } = useExpirationRules()
+
+  const getStorageId = ({ resource, space }: { resource: Resource; space?: SpaceResource }) => {
+    if (isProjectSpaceResource(resource)) {
+      return resource.id
+    }
+
+    if (space) {
+      return space.id
+    }
+
+    return null
+  }
+
+  const createLink = ({
+    resource,
+    name = $gettext('Link'),
+    quicklink = false,
+    space = undefined,
+    permissions = undefined,
+    password = undefined,
+    expireDate = undefined,
+    notifyUploads = undefined,
+    notifyUploadsExtraRecipients = undefined
+  }): Promise<Share> => {
+    const params: Record<string, unknown> = {
+      name,
+      quicklink,
+      spaceRef: resource.fileId || resource.id,
+      storageId: getStorageId({ resource, space }),
+      ...(password && { password }),
+      notifyUploads,
+      notifyUploadsExtraRecipients
+    }
+
+    if (permissions === undefined) {
+      params.permissions = unref(defaultLinkPermissions).toString()
+    }
+
+    if (expireDate === undefined && unref(expirationRules).enforced) {
+      params.expireDate = unref(expirationRules).default
+    }
+
+    let path = resource.path
+    // sharing a share root from the share jail -> use resource name as path
+    if (resource.isReceivedShare() && path === '/') {
+      path = `/${resource.name}`
+    }
+
+    return store.dispatch('Files/addLink', {
+      path,
+      client: clientService.owncloudSdk,
+      params,
+      storageId: resource.fileId || resource.id
+    })
+  }
+
+  return { createLink }
+}
diff --git a/packages/web-pkg/src/composables/links/useDefaultLinkPermissions.ts b/packages/web-pkg/src/composables/links/useDefaultLinkPermissions.ts
new file mode 100644
index 00000000000..31cf22248f5
--- /dev/null
+++ b/packages/web-pkg/src/composables/links/useDefaultLinkPermissions.ts
@@ -0,0 +1,26 @@
+import { computed } from 'vue'
+import { useStore } from '../store'
+import { useAbility } from '../ability'
+import { SharePermissionBit } from '@ownclouders/web-client/src/helpers'
+
+export const useDefaultLinkPermissions = () => {
+  const store = useStore()
+  const ability = useAbility()
+
+  const defaultLinkPermissions = computed(() => {
+    const canCreatePublicLink = ability.can('create-all', 'PublicLink')
+    if (!canCreatePublicLink) {
+      return SharePermissionBit.Internal
+    }
+
+    let defaultPermissions: number =
+      store.state.user.capabilities.files_sharing?.public?.default_permissions
+    if (defaultPermissions === undefined) {
+      defaultPermissions = SharePermissionBit.Read
+    }
+
+    return defaultPermissions
+  })
+
+  return { defaultLinkPermissions }
+}
diff --git a/packages/web-pkg/src/composables/links/useExpirationRules.ts b/packages/web-pkg/src/composables/links/useExpirationRules.ts
index 5a82ad37dc3..16086bb9550 100644
--- a/packages/web-pkg/src/composables/links/useExpirationRules.ts
+++ b/packages/web-pkg/src/composables/links/useExpirationRules.ts
@@ -1,13 +1,46 @@
+import { DateTime } from 'luxon'
 import { computed } from 'vue'
-import { getExpirationRules } from '../../helpers'
 import { useStore } from '../store'
 import { useGettext } from 'vue3-gettext'
+import { PublicExpirationCapability } from '@ownclouders/web-client/src/ocs/capabilities'
+import { getLocaleFromLanguage } from '../../helpers'
+
+export type ExpirationRules = { enforced: boolean; default: DateTime; min: DateTime; max: DateTime }
 
 export const useExpirationRules = () => {
   const store = useStore()
   const { current: currentLanguage } = useGettext()
 
-  const expirationRules = computed(() => getExpirationRules({ store, currentLanguage }))
+  const expirationRules = computed(() => {
+    const expireDate: PublicExpirationCapability =
+      store.getters.capabilities.files_sharing.public.expire_date
+
+    let defaultExpireDate: DateTime = null
+    let maxExpireDateFromCaps: DateTime = null
+
+    if (expireDate.days) {
+      const days = parseInt(expireDate.days)
+      defaultExpireDate = DateTime.now()
+        .setLocale(getLocaleFromLanguage(currentLanguage))
+        .plus({ days })
+        .toJSDate()
+    }
+
+    if (expireDate.enforced) {
+      const days = parseInt(expireDate.days)
+      maxExpireDateFromCaps = DateTime.now()
+        .setLocale(getLocaleFromLanguage(currentLanguage))
+        .plus({ days })
+        .toJSDate()
+    }
+
+    return {
+      enforced: expireDate.enforced,
+      default: defaultExpireDate,
+      min: DateTime.now().setLocale(getLocaleFromLanguage(currentLanguage)).toJSDate(),
+      max: maxExpireDateFromCaps
+    }
+  })
 
   return { expirationRules }
 }
diff --git a/packages/web-pkg/src/helpers/share/index.ts b/packages/web-pkg/src/helpers/share/index.ts
index 81caa3b484c..19c16c5b5c0 100644
--- a/packages/web-pkg/src/helpers/share/index.ts
+++ b/packages/web-pkg/src/helpers/share/index.ts
@@ -1,2 +1 @@
-export * from './link'
 export * from './sharedAncestorRoute'
diff --git a/packages/web-pkg/src/helpers/share/link.ts b/packages/web-pkg/src/helpers/share/link.ts
deleted file mode 100644
index b11e658889d..00000000000
--- a/packages/web-pkg/src/helpers/share/link.ts
+++ /dev/null
@@ -1,247 +0,0 @@
-import { DateTime } from 'luxon'
-import {
-  Share,
-  ShareTypes,
-  buildShare,
-  SharePermissionBit
-} from '@ownclouders/web-client/src/helpers/share'
-import { Store } from 'vuex'
-import { ClientService, PasswordPolicyService } from '../../services'
-import { useClipboard } from '@vueuse/core'
-import { Ability } from '@ownclouders/web-client/src/helpers/resource/types'
-import { Resource } from '@ownclouders/web-client'
-import { Language } from 'vue3-gettext'
-import { unref } from 'vue'
-import { getLocaleFromLanguage } from '../locale'
-import { PublicExpirationCapability } from '@ownclouders/web-client/src/ocs/capabilities'
-
-export interface CreateQuicklink {
-  clientService: ClientService
-  language: Language
-  store: Store<any>
-  storageId?: any
-  resource: Resource
-  password?: string
-  ability: Ability
-}
-
-export interface CopyQuickLink extends CreateQuicklink {
-  passwordPolicyService: PasswordPolicyService
-}
-
-export function showQuickLinkPasswordModal({ $gettext, store, passwordPolicyService }, onConfirm) {
-  const modal = {
-    variation: 'passive',
-    title: $gettext('Set password'),
-    cancelText: $gettext('Cancel'),
-    confirmText: $gettext('Set'),
-    hasInput: true,
-    inputDescription: $gettext('Passwords for links are required.'),
-    inputPasswordPolicy: passwordPolicyService.getPolicy(),
-    inputGeneratePasswordMethod: () => passwordPolicyService.generatePassword(),
-    inputLabel: $gettext('Password'),
-    inputType: 'password',
-    onInput: () => store.dispatch('setModalInputErrorMessage', ''),
-    onPasswordChallengeCompleted: () => store.dispatch('setModalConfirmButtonDisabled', false),
-    onPasswordChallengeFailed: () => store.dispatch('setModalConfirmButtonDisabled', true),
-    onCancel: () => store.dispatch('hideModal'),
-    onConfirm: async (password) => {
-      onConfirm(password)
-    }
-  }
-
-  return store.dispatch('createModal', modal)
-}
-
-// doCopy creates the requested link and copies the url to the clipboard,
-// the copy action uses the clipboard // clipboardItem api to work around the webkit limitations.
-//
-// https://developer.apple.com/forums/thread/691873
-//
-// if those apis not available (or like in firefox behind dom.events.asyncClipboard.clipboardItem)
-// it has a fallback to the vue-use implementation.
-//
-// https://webkit.org/blog/10855/
-const copyToClipboard = (quickLinkUrl: string) => {
-  if (typeof ClipboardItem && navigator?.clipboard?.write) {
-    return navigator.clipboard.write([
-      new ClipboardItem({
-        'text/plain': new Blob([quickLinkUrl], { type: 'text/plain' })
-      })
-    ])
-  } else {
-    const { copy } = useClipboard({ legacy: true })
-    return copy(quickLinkUrl)
-  }
-}
-export const copyQuicklink = async (args: CopyQuickLink) => {
-  const { ability, store, language, resource, clientService, passwordPolicyService } = args
-  const { $gettext } = language
-
-  const linkSharesForResource = await clientService.owncloudSdk.shares.getShares(resource.path, {
-    share_types: ShareTypes?.link?.value?.toString(),
-    include_tags: false
-  })
-
-  const existingQuickLink = linkSharesForResource
-    .map((share: any) => buildShare(share.shareInfo, null, null))
-    .find((share: Share) => share.quicklink === true)
-
-  if (existingQuickLink) {
-    try {
-      await copyToClipboard(existingQuickLink.url)
-      return store.dispatch('showMessage', {
-        title: $gettext('The link has been copied to your clipboard.')
-      })
-    } catch (e) {
-      console.error(e)
-      return store.dispatch('showErrorMessage', {
-        title: $gettext('Copy link failed'),
-        error: e
-      })
-    }
-  }
-
-  const isPasswordEnforced =
-    store.getters.capabilities?.files_sharing?.public?.password?.enforced_for?.read_only === true
-
-  const permissions = getDefaultLinkPermissions({ ability, store })
-
-  if (unref(isPasswordEnforced) && permissions > SharePermissionBit.Internal) {
-    return showQuickLinkPasswordModal(
-      { $gettext, store, passwordPolicyService },
-      async (password: string) => {
-        try {
-          const quickLink = await createQuicklink({ ...args, password })
-          await store.dispatch('hideModal')
-          await copyToClipboard(quickLink.url)
-          return store.dispatch('showMessage', {
-            title: $gettext('The link has been copied to your clipboard.')
-          })
-        } catch (e) {
-          console.log(e)
-
-          // Human-readable error message is provided, for example when password is on banned list
-          if (e.statusCode === 400) {
-            return store.dispatch('setModalInputErrorMessage', $gettext(e.message))
-          }
-
-          return store.dispatch('showErrorMessage', {
-            title: $gettext('Copy link failed'),
-            error: e
-          })
-        }
-      }
-    )
-  }
-
-  try {
-    const quickLink = await createQuicklink(args)
-    await copyToClipboard(quickLink.url)
-    return store.dispatch('showMessage', {
-      title: $gettext('The link has been copied to your clipboard.')
-    })
-  } catch (e) {
-    console.error(e)
-    return store.dispatch('showErrorMessage', {
-      title: $gettext('Copy link failed'),
-      error: e
-    })
-  }
-}
-
-export const createQuicklink = (args: CreateQuicklink): Promise<Share> => {
-  const { clientService, resource, store, password, language, ability } = args
-  const { $gettext } = language
-
-  const params: Record<string, unknown> = {
-    name: $gettext('Link'),
-    permissions: getDefaultLinkPermissions({ ability, store }).toString(),
-    quicklink: true
-  }
-
-  if (password) {
-    params.password = password
-  }
-
-  const expirationDate = store.state.user.capabilities.files_sharing.public.expire_date
-
-  if (expirationDate.enforced) {
-    params.expireDate = DateTime.now()
-      .plus({ days: parseInt(expirationDate.days, 10) })
-      .endOf('day')
-      .toISO()
-  }
-
-  // needs check for enforced password for default role (viewer?)
-  // and concept to what happens if it is enforced
-
-  params.spaceRef = resource.fileId || resource.id
-
-  return store.dispatch('Files/addLink', {
-    path: resource.path,
-    client: clientService.owncloudSdk,
-    params,
-    storageId: resource.fileId || resource.id
-  })
-}
-
-export const getDefaultLinkPermissions = ({
-  ability,
-  store
-}: {
-  ability: Ability
-  store: Store<any>
-}) => {
-  const canCreatePublicLink = ability.can('create-all', 'PublicLink')
-  if (!canCreatePublicLink) {
-    return SharePermissionBit.Internal
-  }
-
-  let defaultPermissions: number =
-    store.state.user.capabilities.files_sharing?.public?.default_permissions
-  if (defaultPermissions === undefined) {
-    defaultPermissions = SharePermissionBit.Read
-  }
-
-  return defaultPermissions
-}
-
-export type ExpirationRules = { enforced: boolean; default: DateTime; min: DateTime; max: DateTime }
-
-export const getExpirationRules = ({
-  store,
-  currentLanguage
-}: {
-  store: Store<any>
-  currentLanguage: string
-}): ExpirationRules => {
-  const expireDate: PublicExpirationCapability =
-    store.getters.capabilities.files_sharing.public.expire_date
-
-  let defaultExpireDate: DateTime = null
-  let maxExpireDateFromCaps: DateTime = null
-
-  if (expireDate.days) {
-    const days = parseInt(expireDate.days)
-    defaultExpireDate = DateTime.now()
-      .setLocale(getLocaleFromLanguage(currentLanguage))
-      .plus({ days })
-      .toJSDate()
-  }
-
-  if (expireDate.enforced) {
-    const days = parseInt(expireDate.days)
-    maxExpireDateFromCaps = DateTime.now()
-      .setLocale(getLocaleFromLanguage(currentLanguage))
-      .plus({ days })
-      .toJSDate()
-  }
-
-  return {
-    enforced: expireDate.enforced,
-    default: defaultExpireDate,
-    min: DateTime.now().setLocale(getLocaleFromLanguage(currentLanguage)).toJSDate(),
-    max: maxExpireDateFromCaps
-  }
-}